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 "config.h" 8#include "advice.h" 9#include "lockfile.h" 10#include "cache-tree.h" 11#include "object-store.h" 12#include "repository.h" 13#include "commit.h" 14#include "blob.h" 15#include "builtin.h" 16#include "tree-walk.h" 17#include "diff.h" 18#include "diffcore.h" 19#include "tag.h" 20#include "alloc.h" 21#include "unpack-trees.h" 22#include "string-list.h" 23#include "xdiff-interface.h" 24#include "ll-merge.h" 25#include "attr.h" 26#include "merge-recursive.h" 27#include "dir.h" 28#include "submodule.h" 29#include "revision.h" 30#include "commit-reach.h" 31 32struct path_hashmap_entry { 33 struct hashmap_entry e; 34 char path[FLEX_ARRAY]; 35}; 36 37static int path_hashmap_cmp(const void *cmp_data, 38 const void *entry, 39 const void *entry_or_key, 40 const void *keydata) 41{ 42 const struct path_hashmap_entry *a = entry; 43 const struct path_hashmap_entry *b = entry_or_key; 44 const char *key = keydata; 45 46 if (ignore_case) 47 return strcasecmp(a->path, key ? key : b->path); 48 else 49 return strcmp(a->path, key ? key : b->path); 50} 51 52static unsigned int path_hash(const char *path) 53{ 54 return ignore_case ? strihash(path) : strhash(path); 55} 56 57static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap, 58 char *dir) 59{ 60 struct dir_rename_entry key; 61 62 if (dir == NULL) 63 return NULL; 64 hashmap_entry_init(&key, strhash(dir)); 65 key.dir = dir; 66 return hashmap_get(hashmap, &key, NULL); 67} 68 69static int dir_rename_cmp(const void *unused_cmp_data, 70 const void *entry, 71 const void *entry_or_key, 72 const void *unused_keydata) 73{ 74 const struct dir_rename_entry *e1 = entry; 75 const struct dir_rename_entry *e2 = entry_or_key; 76 77 return strcmp(e1->dir, e2->dir); 78} 79 80static void dir_rename_init(struct hashmap *map) 81{ 82 hashmap_init(map, dir_rename_cmp, NULL, 0); 83} 84 85static void dir_rename_entry_init(struct dir_rename_entry *entry, 86 char *directory) 87{ 88 hashmap_entry_init(entry, strhash(directory)); 89 entry->dir = directory; 90 entry->non_unique_new_dir = 0; 91 strbuf_init(&entry->new_dir, 0); 92 string_list_init(&entry->possible_new_dirs, 0); 93} 94 95static struct collision_entry *collision_find_entry(struct hashmap *hashmap, 96 char *target_file) 97{ 98 struct collision_entry key; 99 100 hashmap_entry_init(&key, strhash(target_file)); 101 key.target_file = target_file; 102 return hashmap_get(hashmap, &key, NULL); 103} 104 105static int collision_cmp(void *unused_cmp_data, 106 const struct collision_entry *e1, 107 const struct collision_entry *e2, 108 const void *unused_keydata) 109{ 110 return strcmp(e1->target_file, e2->target_file); 111} 112 113static void collision_init(struct hashmap *map) 114{ 115 hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL, 0); 116} 117 118static void flush_output(struct merge_options *o) 119{ 120 if (o->buffer_output < 2 && o->obuf.len) { 121 fputs(o->obuf.buf, stdout); 122 strbuf_reset(&o->obuf); 123 } 124} 125 126static int err(struct merge_options *o, const char *err, ...) 127{ 128 va_list params; 129 130 if (o->buffer_output < 2) 131 flush_output(o); 132 else { 133 strbuf_complete(&o->obuf, '\n'); 134 strbuf_addstr(&o->obuf, "error: "); 135 } 136 va_start(params, err); 137 strbuf_vaddf(&o->obuf, err, params); 138 va_end(params); 139 if (o->buffer_output > 1) 140 strbuf_addch(&o->obuf, '\n'); 141 else { 142 error("%s", o->obuf.buf); 143 strbuf_reset(&o->obuf); 144 } 145 146 return -1; 147} 148 149static struct tree *shift_tree_object(struct repository *repo, 150 struct tree *one, struct tree *two, 151 const char *subtree_shift) 152{ 153 struct object_id shifted; 154 155 if (!*subtree_shift) { 156 shift_tree(&one->object.oid, &two->object.oid, &shifted, 0); 157 } else { 158 shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 159 subtree_shift); 160 } 161 if (oideq(&two->object.oid, &shifted)) 162 return two; 163 return lookup_tree(repo, &shifted); 164} 165 166static struct commit *make_virtual_commit(struct repository *repo, 167 struct tree *tree, 168 const char *comment) 169{ 170 struct commit *commit = alloc_commit_node(repo); 171 172 set_merge_remote_desc(commit, comment, (struct object *)commit); 173 commit->maybe_tree = tree; 174 commit->object.parsed = 1; 175 return commit; 176} 177 178/* 179 * Since we use get_tree_entry(), which does not put the read object into 180 * the object pool, we cannot rely on a == b. 181 */ 182static int oid_eq(const struct object_id *a, const struct object_id *b) 183{ 184 if (!a && !b) 185 return 2; 186 return a && b && oideq(a, b); 187} 188 189enum rename_type { 190 RENAME_NORMAL = 0, 191 RENAME_VIA_DIR, 192 RENAME_ADD, 193 RENAME_DELETE, 194 RENAME_ONE_FILE_TO_ONE, 195 RENAME_ONE_FILE_TO_TWO, 196 RENAME_TWO_FILES_TO_ONE 197}; 198 199struct rename_conflict_info { 200 enum rename_type rename_type; 201 struct diff_filepair *pair1; 202 struct diff_filepair *pair2; 203 const char *branch1; 204 const char *branch2; 205 struct stage_data *dst_entry1; 206 struct stage_data *dst_entry2; 207 struct diff_filespec ren1_other; 208 struct diff_filespec ren2_other; 209}; 210 211/* 212 * Since we want to write the index eventually, we cannot reuse the index 213 * for these (temporary) data. 214 */ 215struct stage_data { 216 struct { 217 unsigned mode; 218 struct object_id oid; 219 } stages[4]; 220 struct rename_conflict_info *rename_conflict_info; 221 unsigned processed:1; 222}; 223 224static inline void setup_rename_conflict_info(enum rename_type rename_type, 225 struct diff_filepair *pair1, 226 struct diff_filepair *pair2, 227 const char *branch1, 228 const char *branch2, 229 struct stage_data *dst_entry1, 230 struct stage_data *dst_entry2, 231 struct merge_options *o, 232 struct stage_data *src_entry1, 233 struct stage_data *src_entry2) 234{ 235 int ostage1 = 0, ostage2; 236 struct rename_conflict_info *ci; 237 238 /* 239 * When we have two renames involved, it's easiest to get the 240 * correct things into stage 2 and 3, and to make sure that the 241 * content merge puts HEAD before the other branch if we just 242 * ensure that branch1 == o->branch1. So, simply flip arguments 243 * around if we don't have that. 244 */ 245 if (dst_entry2 && branch1 != o->branch1) { 246 setup_rename_conflict_info(rename_type, 247 pair2, pair1, 248 branch2, branch1, 249 dst_entry2, dst_entry1, 250 o, 251 src_entry2, src_entry1); 252 return; 253 } 254 255 ci = xcalloc(1, sizeof(struct rename_conflict_info)); 256 ci->rename_type = rename_type; 257 ci->pair1 = pair1; 258 ci->branch1 = branch1; 259 ci->branch2 = branch2; 260 261 ci->dst_entry1 = dst_entry1; 262 dst_entry1->rename_conflict_info = ci; 263 dst_entry1->processed = 0; 264 265 assert(!pair2 == !dst_entry2); 266 if (dst_entry2) { 267 ci->dst_entry2 = dst_entry2; 268 ci->pair2 = pair2; 269 dst_entry2->rename_conflict_info = ci; 270 } 271 272 /* 273 * For each rename, there could have been 274 * modifications on the side of history where that 275 * file was not renamed. 276 */ 277 if (rename_type == RENAME_ADD || 278 rename_type == RENAME_TWO_FILES_TO_ONE) { 279 ostage1 = o->branch1 == branch1 ? 3 : 2; 280 281 ci->ren1_other.path = pair1->one->path; 282 oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid); 283 ci->ren1_other.mode = src_entry1->stages[ostage1].mode; 284 } 285 286 if (rename_type == RENAME_TWO_FILES_TO_ONE) { 287 ostage2 = ostage1 ^ 1; 288 289 ci->ren2_other.path = pair2->one->path; 290 oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid); 291 ci->ren2_other.mode = src_entry2->stages[ostage2].mode; 292 } 293} 294 295static int show(struct merge_options *o, int v) 296{ 297 return (!o->call_depth && o->verbosity >= v) || o->verbosity >= 5; 298} 299 300__attribute__((format (printf, 3, 4))) 301static void output(struct merge_options *o, int v, const char *fmt, ...) 302{ 303 va_list ap; 304 305 if (!show(o, v)) 306 return; 307 308 strbuf_addchars(&o->obuf, ' ', o->call_depth * 2); 309 310 va_start(ap, fmt); 311 strbuf_vaddf(&o->obuf, fmt, ap); 312 va_end(ap); 313 314 strbuf_addch(&o->obuf, '\n'); 315 if (!o->buffer_output) 316 flush_output(o); 317} 318 319static void output_commit_title(struct merge_options *o, struct commit *commit) 320{ 321 struct merge_remote_desc *desc; 322 323 strbuf_addchars(&o->obuf, ' ', o->call_depth * 2); 324 desc = merge_remote_util(commit); 325 if (desc) 326 strbuf_addf(&o->obuf, "virtual %s\n", desc->name); 327 else { 328 strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid, 329 DEFAULT_ABBREV); 330 strbuf_addch(&o->obuf, ' '); 331 if (parse_commit(commit) != 0) 332 strbuf_addstr(&o->obuf, _("(bad commit)\n")); 333 else { 334 const char *title; 335 const char *msg = get_commit_buffer(commit, NULL); 336 int len = find_commit_subject(msg, &title); 337 if (len) 338 strbuf_addf(&o->obuf, "%.*s\n", len, title); 339 unuse_commit_buffer(commit, msg); 340 } 341 } 342 flush_output(o); 343} 344 345static int add_cacheinfo(struct merge_options *o, 346 unsigned int mode, const struct object_id *oid, 347 const char *path, int stage, int refresh, int options) 348{ 349 struct index_state *istate = o->repo->index; 350 struct cache_entry *ce; 351 int ret; 352 353 ce = make_cache_entry(istate, mode, oid ? oid : &null_oid, path, stage, 0); 354 if (!ce) 355 return err(o, _("add_cacheinfo failed for path '%s'; merge aborting."), path); 356 357 ret = add_index_entry(istate, ce, options); 358 if (refresh) { 359 struct cache_entry *nce; 360 361 nce = refresh_cache_entry(istate, ce, 362 CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 363 if (!nce) 364 return err(o, _("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); 365 if (nce != ce) 366 ret = add_index_entry(istate, nce, options); 367 } 368 return ret; 369} 370 371static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree) 372{ 373 parse_tree(tree); 374 init_tree_desc(desc, tree->buffer, tree->size); 375} 376 377static int unpack_trees_start(struct merge_options *o, 378 struct tree *common, 379 struct tree *head, 380 struct tree *merge) 381{ 382 int rc; 383 struct tree_desc t[3]; 384 struct index_state tmp_index = { NULL }; 385 386 memset(&o->unpack_opts, 0, sizeof(o->unpack_opts)); 387 if (o->call_depth) 388 o->unpack_opts.index_only = 1; 389 else 390 o->unpack_opts.update = 1; 391 o->unpack_opts.merge = 1; 392 o->unpack_opts.head_idx = 2; 393 o->unpack_opts.fn = threeway_merge; 394 o->unpack_opts.src_index = o->repo->index; 395 o->unpack_opts.dst_index = &tmp_index; 396 o->unpack_opts.aggressive = !merge_detect_rename(o); 397 setup_unpack_trees_porcelain(&o->unpack_opts, "merge"); 398 399 init_tree_desc_from_tree(t+0, common); 400 init_tree_desc_from_tree(t+1, head); 401 init_tree_desc_from_tree(t+2, merge); 402 403 rc = unpack_trees(3, t, &o->unpack_opts); 404 cache_tree_free(&o->repo->index->cache_tree); 405 406 /* 407 * Update o->repo->index to match the new results, AFTER saving a copy 408 * in o->orig_index. Update src_index to point to the saved copy. 409 * (verify_uptodate() checks src_index, and the original index is 410 * the one that had the necessary modification timestamps.) 411 */ 412 o->orig_index = *o->repo->index; 413 *o->repo->index = tmp_index; 414 o->unpack_opts.src_index = &o->orig_index; 415 416 return rc; 417} 418 419static void unpack_trees_finish(struct merge_options *o) 420{ 421 discard_index(&o->orig_index); 422 clear_unpack_trees_porcelain(&o->unpack_opts); 423} 424 425struct tree *write_tree_from_memory(struct merge_options *o) 426{ 427 struct tree *result = NULL; 428 struct index_state *istate = o->repo->index; 429 430 if (unmerged_index(istate)) { 431 int i; 432 fprintf(stderr, "BUG: There are unmerged index entries:\n"); 433 for (i = 0; i < istate->cache_nr; i++) { 434 const struct cache_entry *ce = istate->cache[i]; 435 if (ce_stage(ce)) 436 fprintf(stderr, "BUG: %d %.*s\n", ce_stage(ce), 437 (int)ce_namelen(ce), ce->name); 438 } 439 BUG("unmerged index entries in merge-recursive.c"); 440 } 441 442 if (!istate->cache_tree) 443 istate->cache_tree = cache_tree(); 444 445 if (!cache_tree_fully_valid(istate->cache_tree) && 446 cache_tree_update(istate, 0) < 0) { 447 err(o, _("error building trees")); 448 return NULL; 449 } 450 451 result = lookup_tree(o->repo, &istate->cache_tree->oid); 452 453 return result; 454} 455 456static int save_files_dirs(const struct object_id *oid, 457 struct strbuf *base, const char *path, 458 unsigned int mode, int stage, void *context) 459{ 460 struct path_hashmap_entry *entry; 461 int baselen = base->len; 462 struct merge_options *o = context; 463 464 strbuf_addstr(base, path); 465 466 FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 467 hashmap_entry_init(entry, path_hash(entry->path)); 468 hashmap_add(&o->current_file_dir_set, entry); 469 470 strbuf_setlen(base, baselen); 471 return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0); 472} 473 474static void get_files_dirs(struct merge_options *o, struct tree *tree) 475{ 476 struct pathspec match_all; 477 memset(&match_all, 0, sizeof(match_all)); 478 read_tree_recursive(the_repository, tree, "", 0, 0, 479 &match_all, save_files_dirs, o); 480} 481 482static int get_tree_entry_if_blob(const struct object_id *tree, 483 const char *path, 484 struct object_id *hashy, 485 unsigned int *mode_o) 486{ 487 int ret; 488 489 ret = get_tree_entry(tree, path, hashy, mode_o); 490 if (S_ISDIR(*mode_o)) { 491 oidcpy(hashy, &null_oid); 492 *mode_o = 0; 493 } 494 return ret; 495} 496 497/* 498 * Returns an index_entry instance which doesn't have to correspond to 499 * a real cache entry in Git's index. 500 */ 501static struct stage_data *insert_stage_data(const char *path, 502 struct tree *o, struct tree *a, struct tree *b, 503 struct string_list *entries) 504{ 505 struct string_list_item *item; 506 struct stage_data *e = xcalloc(1, sizeof(struct stage_data)); 507 get_tree_entry_if_blob(&o->object.oid, path, 508 &e->stages[1].oid, &e->stages[1].mode); 509 get_tree_entry_if_blob(&a->object.oid, path, 510 &e->stages[2].oid, &e->stages[2].mode); 511 get_tree_entry_if_blob(&b->object.oid, path, 512 &e->stages[3].oid, &e->stages[3].mode); 513 item = string_list_insert(entries, path); 514 item->util = e; 515 return e; 516} 517 518/* 519 * Create a dictionary mapping file names to stage_data objects. The 520 * dictionary contains one entry for every path with a non-zero stage entry. 521 */ 522static struct string_list *get_unmerged(struct index_state *istate) 523{ 524 struct string_list *unmerged = xcalloc(1, sizeof(struct string_list)); 525 int i; 526 527 unmerged->strdup_strings = 1; 528 529 for (i = 0; i < istate->cache_nr; i++) { 530 struct string_list_item *item; 531 struct stage_data *e; 532 const struct cache_entry *ce = istate->cache[i]; 533 if (!ce_stage(ce)) 534 continue; 535 536 item = string_list_lookup(unmerged, ce->name); 537 if (!item) { 538 item = string_list_insert(unmerged, ce->name); 539 item->util = xcalloc(1, sizeof(struct stage_data)); 540 } 541 e = item->util; 542 e->stages[ce_stage(ce)].mode = ce->ce_mode; 543 oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 544 } 545 546 return unmerged; 547} 548 549static int string_list_df_name_compare(const char *one, const char *two) 550{ 551 int onelen = strlen(one); 552 int twolen = strlen(two); 553 /* 554 * Here we only care that entries for D/F conflicts are 555 * adjacent, in particular with the file of the D/F conflict 556 * appearing before files below the corresponding directory. 557 * The order of the rest of the list is irrelevant for us. 558 * 559 * To achieve this, we sort with df_name_compare and provide 560 * the mode S_IFDIR so that D/F conflicts will sort correctly. 561 * We use the mode S_IFDIR for everything else for simplicity, 562 * since in other cases any changes in their order due to 563 * sorting cause no problems for us. 564 */ 565 int cmp = df_name_compare(one, onelen, S_IFDIR, 566 two, twolen, S_IFDIR); 567 /* 568 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 569 * that 'foo' comes before 'foo/bar'. 570 */ 571 if (cmp) 572 return cmp; 573 return onelen - twolen; 574} 575 576static void record_df_conflict_files(struct merge_options *o, 577 struct string_list *entries) 578{ 579 /* If there is a D/F conflict and the file for such a conflict 580 * currently exists in the working tree, we want to allow it to be 581 * removed to make room for the corresponding directory if needed. 582 * The files underneath the directories of such D/F conflicts will 583 * be processed before the corresponding file involved in the D/F 584 * conflict. If the D/F directory ends up being removed by the 585 * merge, then we won't have to touch the D/F file. If the D/F 586 * directory needs to be written to the working copy, then the D/F 587 * file will simply be removed (in make_room_for_path()) to make 588 * room for the necessary paths. Note that if both the directory 589 * and the file need to be present, then the D/F file will be 590 * reinstated with a new unique name at the time it is processed. 591 */ 592 struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 593 const char *last_file = NULL; 594 int last_len = 0; 595 int i; 596 597 /* 598 * If we're merging merge-bases, we don't want to bother with 599 * any working directory changes. 600 */ 601 if (o->call_depth) 602 return; 603 604 /* Ensure D/F conflicts are adjacent in the entries list. */ 605 for (i = 0; i < entries->nr; i++) { 606 struct string_list_item *next = &entries->items[i]; 607 string_list_append(&df_sorted_entries, next->string)->util = 608 next->util; 609 } 610 df_sorted_entries.cmp = string_list_df_name_compare; 611 string_list_sort(&df_sorted_entries); 612 613 string_list_clear(&o->df_conflict_file_set, 1); 614 for (i = 0; i < df_sorted_entries.nr; i++) { 615 const char *path = df_sorted_entries.items[i].string; 616 int len = strlen(path); 617 struct stage_data *e = df_sorted_entries.items[i].util; 618 619 /* 620 * Check if last_file & path correspond to a D/F conflict; 621 * i.e. whether path is last_file+'/'+<something>. 622 * If so, record that it's okay to remove last_file to make 623 * room for path and friends if needed. 624 */ 625 if (last_file && 626 len > last_len && 627 memcmp(path, last_file, last_len) == 0 && 628 path[last_len] == '/') { 629 string_list_insert(&o->df_conflict_file_set, last_file); 630 } 631 632 /* 633 * Determine whether path could exist as a file in the 634 * working directory as a possible D/F conflict. This 635 * will only occur when it exists in stage 2 as a 636 * file. 637 */ 638 if (S_ISREG(e->stages[2].mode) || S_ISLNK(e->stages[2].mode)) { 639 last_file = path; 640 last_len = len; 641 } else { 642 last_file = NULL; 643 } 644 } 645 string_list_clear(&df_sorted_entries, 0); 646} 647 648struct rename { 649 struct diff_filepair *pair; 650 /* 651 * Purpose of src_entry and dst_entry: 652 * 653 * If 'before' is renamed to 'after' then src_entry will contain 654 * the versions of 'before' from the merge_base, HEAD, and MERGE in 655 * stages 1, 2, and 3; dst_entry will contain the respective 656 * versions of 'after' in corresponding locations. Thus, we have a 657 * total of six modes and oids, though some will be null. (Stage 0 658 * is ignored; we're interested in handling conflicts.) 659 * 660 * Since we don't turn on break-rewrites by default, neither 661 * src_entry nor dst_entry can have all three of their stages have 662 * non-null oids, meaning at most four of the six will be non-null. 663 * Also, since this is a rename, both src_entry and dst_entry will 664 * have at least one non-null oid, meaning at least two will be 665 * non-null. Of the six oids, a typical rename will have three be 666 * non-null. Only two implies a rename/delete, and four implies a 667 * rename/add. 668 */ 669 struct stage_data *src_entry; 670 struct stage_data *dst_entry; 671 unsigned add_turned_into_rename:1; 672 unsigned processed:1; 673}; 674 675static int update_stages(struct merge_options *opt, const char *path, 676 const struct diff_filespec *o, 677 const struct diff_filespec *a, 678 const struct diff_filespec *b) 679{ 680 681 /* 682 * NOTE: It is usually a bad idea to call update_stages on a path 683 * before calling update_file on that same path, since it can 684 * sometimes lead to spurious "refusing to lose untracked file..." 685 * messages from update_file (via make_room_for path via 686 * would_lose_untracked). Instead, reverse the order of the calls 687 * (executing update_file first and then update_stages). 688 */ 689 int clear = 1; 690 int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 691 if (clear) 692 if (remove_file_from_index(opt->repo->index, path)) 693 return -1; 694 if (o) 695 if (add_cacheinfo(opt, o->mode, &o->oid, path, 1, 0, options)) 696 return -1; 697 if (a) 698 if (add_cacheinfo(opt, a->mode, &a->oid, path, 2, 0, options)) 699 return -1; 700 if (b) 701 if (add_cacheinfo(opt, b->mode, &b->oid, path, 3, 0, options)) 702 return -1; 703 return 0; 704} 705 706static void update_entry(struct stage_data *entry, 707 struct diff_filespec *o, 708 struct diff_filespec *a, 709 struct diff_filespec *b) 710{ 711 entry->processed = 0; 712 entry->stages[1].mode = o->mode; 713 entry->stages[2].mode = a->mode; 714 entry->stages[3].mode = b->mode; 715 oidcpy(&entry->stages[1].oid, &o->oid); 716 oidcpy(&entry->stages[2].oid, &a->oid); 717 oidcpy(&entry->stages[3].oid, &b->oid); 718} 719 720static int remove_file(struct merge_options *o, int clean, 721 const char *path, int no_wd) 722{ 723 int update_cache = o->call_depth || clean; 724 int update_working_directory = !o->call_depth && !no_wd; 725 726 if (update_cache) { 727 if (remove_file_from_index(o->repo->index, path)) 728 return -1; 729 } 730 if (update_working_directory) { 731 if (ignore_case) { 732 struct cache_entry *ce; 733 ce = index_file_exists(o->repo->index, path, strlen(path), 734 ignore_case); 735 if (ce && ce_stage(ce) == 0 && strcmp(path, ce->name)) 736 return 0; 737 } 738 if (remove_path(path)) 739 return -1; 740 } 741 return 0; 742} 743 744/* add a string to a strbuf, but converting "/" to "_" */ 745static void add_flattened_path(struct strbuf *out, const char *s) 746{ 747 size_t i = out->len; 748 strbuf_addstr(out, s); 749 for (; i < out->len; i++) 750 if (out->buf[i] == '/') 751 out->buf[i] = '_'; 752} 753 754static char *unique_path(struct merge_options *o, const char *path, const char *branch) 755{ 756 struct path_hashmap_entry *entry; 757 struct strbuf newpath = STRBUF_INIT; 758 int suffix = 0; 759 size_t base_len; 760 761 strbuf_addf(&newpath, "%s~", path); 762 add_flattened_path(&newpath, branch); 763 764 base_len = newpath.len; 765 while (hashmap_get_from_hash(&o->current_file_dir_set, 766 path_hash(newpath.buf), newpath.buf) || 767 (!o->call_depth && file_exists(newpath.buf))) { 768 strbuf_setlen(&newpath, base_len); 769 strbuf_addf(&newpath, "_%d", suffix++); 770 } 771 772 FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 773 hashmap_entry_init(entry, path_hash(entry->path)); 774 hashmap_add(&o->current_file_dir_set, entry); 775 return strbuf_detach(&newpath, NULL); 776} 777 778/** 779 * Check whether a directory in the index is in the way of an incoming 780 * file. Return 1 if so. If check_working_copy is non-zero, also 781 * check the working directory. If empty_ok is non-zero, also return 782 * 0 in the case where the working-tree dir exists but is empty. 783 */ 784static int dir_in_way(struct index_state *istate, const char *path, 785 int check_working_copy, int empty_ok) 786{ 787 int pos; 788 struct strbuf dirpath = STRBUF_INIT; 789 struct stat st; 790 791 strbuf_addstr(&dirpath, path); 792 strbuf_addch(&dirpath, '/'); 793 794 pos = index_name_pos(istate, dirpath.buf, dirpath.len); 795 796 if (pos < 0) 797 pos = -1 - pos; 798 if (pos < istate->cache_nr && 799 !strncmp(dirpath.buf, istate->cache[pos]->name, dirpath.len)) { 800 strbuf_release(&dirpath); 801 return 1; 802 } 803 804 strbuf_release(&dirpath); 805 return check_working_copy && !lstat(path, &st) && S_ISDIR(st.st_mode) && 806 !(empty_ok && is_empty_dir(path)); 807} 808 809/* 810 * Returns whether path was tracked in the index before the merge started, 811 * and its oid and mode match the specified values 812 */ 813static int was_tracked_and_matches(struct merge_options *o, const char *path, 814 const struct object_id *oid, unsigned mode) 815{ 816 int pos = index_name_pos(&o->orig_index, path, strlen(path)); 817 struct cache_entry *ce; 818 819 if (0 > pos) 820 /* we were not tracking this path before the merge */ 821 return 0; 822 823 /* See if the file we were tracking before matches */ 824 ce = o->orig_index.cache[pos]; 825 return (oid_eq(&ce->oid, oid) && ce->ce_mode == mode); 826} 827 828/* 829 * Returns whether path was tracked in the index before the merge started 830 */ 831static int was_tracked(struct merge_options *o, const char *path) 832{ 833 int pos = index_name_pos(&o->orig_index, path, strlen(path)); 834 835 if (0 <= pos) 836 /* we were tracking this path before the merge */ 837 return 1; 838 839 return 0; 840} 841 842static int would_lose_untracked(struct merge_options *o, const char *path) 843{ 844 struct index_state *istate = o->repo->index; 845 846 /* 847 * This may look like it can be simplified to: 848 * return !was_tracked(o, path) && file_exists(path) 849 * but it can't. This function needs to know whether path was in 850 * the working tree due to EITHER having been tracked in the index 851 * before the merge OR having been put into the working copy and 852 * index by unpack_trees(). Due to that either-or requirement, we 853 * check the current index instead of the original one. 854 * 855 * Note that we do not need to worry about merge-recursive itself 856 * updating the index after unpack_trees() and before calling this 857 * function, because we strictly require all code paths in 858 * merge-recursive to update the working tree first and the index 859 * second. Doing otherwise would break 860 * update_file()/would_lose_untracked(); see every comment in this 861 * file which mentions "update_stages". 862 */ 863 int pos = index_name_pos(istate, path, strlen(path)); 864 865 if (pos < 0) 866 pos = -1 - pos; 867 while (pos < istate->cache_nr && 868 !strcmp(path, istate->cache[pos]->name)) { 869 /* 870 * If stage #0, it is definitely tracked. 871 * If it has stage #2 then it was tracked 872 * before this merge started. All other 873 * cases the path was not tracked. 874 */ 875 switch (ce_stage(istate->cache[pos])) { 876 case 0: 877 case 2: 878 return 0; 879 } 880 pos++; 881 } 882 return file_exists(path); 883} 884 885static int was_dirty(struct merge_options *o, const char *path) 886{ 887 struct cache_entry *ce; 888 int dirty = 1; 889 890 if (o->call_depth || !was_tracked(o, path)) 891 return !dirty; 892 893 ce = index_file_exists(o->unpack_opts.src_index, 894 path, strlen(path), ignore_case); 895 dirty = verify_uptodate(ce, &o->unpack_opts) != 0; 896 return dirty; 897} 898 899static int make_room_for_path(struct merge_options *o, const char *path) 900{ 901 int status, i; 902 const char *msg = _("failed to create path '%s'%s"); 903 904 /* Unlink any D/F conflict files that are in the way */ 905 for (i = 0; i < o->df_conflict_file_set.nr; i++) { 906 const char *df_path = o->df_conflict_file_set.items[i].string; 907 size_t pathlen = strlen(path); 908 size_t df_pathlen = strlen(df_path); 909 if (df_pathlen < pathlen && 910 path[df_pathlen] == '/' && 911 strncmp(path, df_path, df_pathlen) == 0) { 912 output(o, 3, 913 _("Removing %s to make room for subdirectory\n"), 914 df_path); 915 unlink(df_path); 916 unsorted_string_list_delete_item(&o->df_conflict_file_set, 917 i, 0); 918 break; 919 } 920 } 921 922 /* Make sure leading directories are created */ 923 status = safe_create_leading_directories_const(path); 924 if (status) { 925 if (status == SCLD_EXISTS) 926 /* something else exists */ 927 return err(o, msg, path, _(": perhaps a D/F conflict?")); 928 return err(o, msg, path, ""); 929 } 930 931 /* 932 * Do not unlink a file in the work tree if we are not 933 * tracking it. 934 */ 935 if (would_lose_untracked(o, path)) 936 return err(o, _("refusing to lose untracked file at '%s'"), 937 path); 938 939 /* Successful unlink is good.. */ 940 if (!unlink(path)) 941 return 0; 942 /* .. and so is no existing file */ 943 if (errno == ENOENT) 944 return 0; 945 /* .. but not some other error (who really cares what?) */ 946 return err(o, msg, path, _(": perhaps a D/F conflict?")); 947} 948 949static int update_file_flags(struct merge_options *o, 950 const struct object_id *oid, 951 unsigned mode, 952 const char *path, 953 int update_cache, 954 int update_wd) 955{ 956 int ret = 0; 957 958 if (o->call_depth) 959 update_wd = 0; 960 961 if (update_wd) { 962 enum object_type type; 963 void *buf; 964 unsigned long size; 965 966 if (S_ISGITLINK(mode)) { 967 /* 968 * We may later decide to recursively descend into 969 * the submodule directory and update its index 970 * and/or work tree, but we do not do that now. 971 */ 972 update_wd = 0; 973 goto update_index; 974 } 975 976 buf = read_object_file(oid, &type, &size); 977 if (!buf) 978 return err(o, _("cannot read object %s '%s'"), oid_to_hex(oid), path); 979 if (type != OBJ_BLOB) { 980 ret = err(o, _("blob expected for %s '%s'"), oid_to_hex(oid), path); 981 goto free_buf; 982 } 983 if (S_ISREG(mode)) { 984 struct strbuf strbuf = STRBUF_INIT; 985 if (convert_to_working_tree(o->repo->index, path, buf, size, &strbuf)) { 986 free(buf); 987 size = strbuf.len; 988 buf = strbuf_detach(&strbuf, NULL); 989 } 990 } 991 992 if (make_room_for_path(o, path) < 0) { 993 update_wd = 0; 994 goto free_buf; 995 } 996 if (S_ISREG(mode) || (!has_symlinks && S_ISLNK(mode))) { 997 int fd; 998 if (mode & 0100) 999 mode = 0777;1000 else1001 mode = 0666;1002 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);1003 if (fd < 0) {1004 ret = err(o, _("failed to open '%s': %s"),1005 path, strerror(errno));1006 goto free_buf;1007 }1008 write_in_full(fd, buf, size);1009 close(fd);1010 } else if (S_ISLNK(mode)) {1011 char *lnk = xmemdupz(buf, size);1012 safe_create_leading_directories_const(path);1013 unlink(path);1014 if (symlink(lnk, path))1015 ret = err(o, _("failed to symlink '%s': %s"),1016 path, strerror(errno));1017 free(lnk);1018 } else1019 ret = err(o,1020 _("do not know what to do with %06o %s '%s'"),1021 mode, oid_to_hex(oid), path);1022 free_buf:1023 free(buf);1024 }1025update_index:1026 if (!ret && update_cache)1027 if (add_cacheinfo(o, mode, oid, path, 0, update_wd,1028 ADD_CACHE_OK_TO_ADD))1029 return -1;1030 return ret;1031}10321033static int update_file(struct merge_options *o,1034 int clean,1035 const struct object_id *oid,1036 unsigned mode,1037 const char *path)1038{1039 return update_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth);1040}10411042/* Low level file merging, update and removal */10431044struct merge_file_info {1045 struct object_id oid;1046 unsigned mode;1047 unsigned clean:1,1048 merge:1;1049};10501051static int merge_3way(struct merge_options *o,1052 mmbuffer_t *result_buf,1053 const struct diff_filespec *one,1054 const struct diff_filespec *a,1055 const struct diff_filespec *b,1056 const char *branch1,1057 const char *branch2,1058 const int extra_marker_size)1059{1060 mmfile_t orig, src1, src2;1061 struct ll_merge_options ll_opts = {0};1062 char *base_name, *name1, *name2;1063 int merge_status;10641065 ll_opts.renormalize = o->renormalize;1066 ll_opts.extra_marker_size = extra_marker_size;1067 ll_opts.xdl_opts = o->xdl_opts;10681069 if (o->call_depth) {1070 ll_opts.virtual_ancestor = 1;1071 ll_opts.variant = 0;1072 } else {1073 switch (o->recursive_variant) {1074 case MERGE_RECURSIVE_OURS:1075 ll_opts.variant = XDL_MERGE_FAVOR_OURS;1076 break;1077 case MERGE_RECURSIVE_THEIRS:1078 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;1079 break;1080 default:1081 ll_opts.variant = 0;1082 break;1083 }1084 }10851086 if (strcmp(a->path, b->path) ||1087 (o->ancestor != NULL && strcmp(a->path, one->path) != 0)) {1088 base_name = o->ancestor == NULL ? NULL :1089 mkpathdup("%s:%s", o->ancestor, one->path);1090 name1 = mkpathdup("%s:%s", branch1, a->path);1091 name2 = mkpathdup("%s:%s", branch2, b->path);1092 } else {1093 base_name = o->ancestor == NULL ? NULL :1094 mkpathdup("%s", o->ancestor);1095 name1 = mkpathdup("%s", branch1);1096 name2 = mkpathdup("%s", branch2);1097 }10981099 read_mmblob(&orig, &one->oid);1100 read_mmblob(&src1, &a->oid);1101 read_mmblob(&src2, &b->oid);11021103 merge_status = ll_merge(result_buf, a->path, &orig, base_name,1104 &src1, name1, &src2, name2,1105 o->repo->index, &ll_opts);11061107 free(base_name);1108 free(name1);1109 free(name2);1110 free(orig.ptr);1111 free(src1.ptr);1112 free(src2.ptr);1113 return merge_status;1114}11151116static int find_first_merges(struct repository *repo,1117 struct object_array *result, const char *path,1118 struct commit *a, struct commit *b)1119{1120 int i, j;1121 struct object_array merges = OBJECT_ARRAY_INIT;1122 struct commit *commit;1123 int contains_another;11241125 char merged_revision[42];1126 const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",1127 "--all", merged_revision, NULL };1128 struct rev_info revs;1129 struct setup_revision_opt rev_opts;11301131 memset(result, 0, sizeof(struct object_array));1132 memset(&rev_opts, 0, sizeof(rev_opts));11331134 /* get all revisions that merge commit a */1135 xsnprintf(merged_revision, sizeof(merged_revision), "^%s",1136 oid_to_hex(&a->object.oid));1137 repo_init_revisions(repo, &revs, NULL);1138 rev_opts.submodule = path;1139 /* FIXME: can't handle linked worktrees in submodules yet */1140 revs.single_worktree = path != NULL;1141 setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);11421143 /* save all revisions from the above list that contain b */1144 if (prepare_revision_walk(&revs))1145 die("revision walk setup failed");1146 while ((commit = get_revision(&revs)) != NULL) {1147 struct object *o = &(commit->object);1148 if (in_merge_bases(b, commit))1149 add_object_array(o, NULL, &merges);1150 }1151 reset_revision_walk();11521153 /* Now we've got all merges that contain a and b. Prune all1154 * merges that contain another found merge and save them in1155 * result.1156 */1157 for (i = 0; i < merges.nr; i++) {1158 struct commit *m1 = (struct commit *) merges.objects[i].item;11591160 contains_another = 0;1161 for (j = 0; j < merges.nr; j++) {1162 struct commit *m2 = (struct commit *) merges.objects[j].item;1163 if (i != j && in_merge_bases(m2, m1)) {1164 contains_another = 1;1165 break;1166 }1167 }11681169 if (!contains_another)1170 add_object_array(merges.objects[i].item, NULL, result);1171 }11721173 object_array_clear(&merges);1174 return result->nr;1175}11761177static void print_commit(struct commit *commit)1178{1179 struct strbuf sb = STRBUF_INIT;1180 struct pretty_print_context ctx = {0};1181 ctx.date_mode.type = DATE_NORMAL;1182 format_commit_message(commit, " %h: %m %s", &sb, &ctx);1183 fprintf(stderr, "%s\n", sb.buf);1184 strbuf_release(&sb);1185}11861187static int merge_submodule(struct merge_options *o,1188 struct object_id *result, const char *path,1189 const struct object_id *base, const struct object_id *a,1190 const struct object_id *b)1191{1192 struct commit *commit_base, *commit_a, *commit_b;1193 int parent_count;1194 struct object_array merges;11951196 int i;1197 int search = !o->call_depth;11981199 /* store a in result in case we fail */1200 oidcpy(result, a);12011202 /* we can not handle deletion conflicts */1203 if (is_null_oid(base))1204 return 0;1205 if (is_null_oid(a))1206 return 0;1207 if (is_null_oid(b))1208 return 0;12091210 if (add_submodule_odb(path)) {1211 output(o, 1, _("Failed to merge submodule %s (not checked out)"), path);1212 return 0;1213 }12141215 if (!(commit_base = lookup_commit_reference(o->repo, base)) ||1216 !(commit_a = lookup_commit_reference(o->repo, a)) ||1217 !(commit_b = lookup_commit_reference(o->repo, b))) {1218 output(o, 1, _("Failed to merge submodule %s (commits not present)"), path);1219 return 0;1220 }12211222 /* check whether both changes are forward */1223 if (!in_merge_bases(commit_base, commit_a) ||1224 !in_merge_bases(commit_base, commit_b)) {1225 output(o, 1, _("Failed to merge submodule %s (commits don't follow merge-base)"), path);1226 return 0;1227 }12281229 /* Case #1: a is contained in b or vice versa */1230 if (in_merge_bases(commit_a, commit_b)) {1231 oidcpy(result, b);1232 if (show(o, 3)) {1233 output(o, 3, _("Fast-forwarding submodule %s to the following commit:"), path);1234 output_commit_title(o, commit_b);1235 } else if (show(o, 2))1236 output(o, 2, _("Fast-forwarding submodule %s"), path);1237 else1238 ; /* no output */12391240 return 1;1241 }1242 if (in_merge_bases(commit_b, commit_a)) {1243 oidcpy(result, a);1244 if (show(o, 3)) {1245 output(o, 3, _("Fast-forwarding submodule %s to the following commit:"), path);1246 output_commit_title(o, commit_a);1247 } else if (show(o, 2))1248 output(o, 2, _("Fast-forwarding submodule %s"), path);1249 else1250 ; /* no output */12511252 return 1;1253 }12541255 /*1256 * Case #2: There are one or more merges that contain a and b in1257 * the submodule. If there is only one, then present it as a1258 * suggestion to the user, but leave it marked unmerged so the1259 * user needs to confirm the resolution.1260 */12611262 /* Skip the search if makes no sense to the calling context. */1263 if (!search)1264 return 0;12651266 /* find commit which merges them */1267 parent_count = find_first_merges(o->repo, &merges, path,1268 commit_a, commit_b);1269 switch (parent_count) {1270 case 0:1271 output(o, 1, _("Failed to merge submodule %s (merge following commits not found)"), path);1272 break;12731274 case 1:1275 output(o, 1, _("Failed to merge submodule %s (not fast-forward)"), path);1276 output(o, 2, _("Found a possible merge resolution for the submodule:\n"));1277 print_commit((struct commit *) merges.objects[0].item);1278 output(o, 2, _(1279 "If this is correct simply add it to the index "1280 "for example\n"1281 "by using:\n\n"1282 " git update-index --cacheinfo 160000 %s \"%s\"\n\n"1283 "which will accept this suggestion.\n"),1284 oid_to_hex(&merges.objects[0].item->oid), path);1285 break;12861287 default:1288 output(o, 1, _("Failed to merge submodule %s (multiple merges found)"), path);1289 for (i = 0; i < merges.nr; i++)1290 print_commit((struct commit *) merges.objects[i].item);1291 }12921293 object_array_clear(&merges);1294 return 0;1295}12961297static int merge_mode_and_contents(struct merge_options *o,1298 const struct diff_filespec *one,1299 const struct diff_filespec *a,1300 const struct diff_filespec *b,1301 const char *filename,1302 const char *branch1,1303 const char *branch2,1304 const int extra_marker_size,1305 struct merge_file_info *result)1306{1307 if (o->branch1 != branch1) {1308 /*1309 * It's weird getting a reverse merge with HEAD on the bottom1310 * side of the conflict markers and the other branch on the1311 * top. Fix that.1312 */1313 return merge_mode_and_contents(o, one, b, a,1314 filename,1315 branch2, branch1,1316 extra_marker_size, result);1317 }13181319 result->merge = 0;1320 result->clean = 1;13211322 if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {1323 result->clean = 0;1324 if (S_ISREG(a->mode)) {1325 result->mode = a->mode;1326 oidcpy(&result->oid, &a->oid);1327 } else {1328 result->mode = b->mode;1329 oidcpy(&result->oid, &b->oid);1330 }1331 } else {1332 if (!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))1333 result->merge = 1;13341335 /*1336 * Merge modes1337 */1338 if (a->mode == b->mode || a->mode == one->mode)1339 result->mode = b->mode;1340 else {1341 result->mode = a->mode;1342 if (b->mode != one->mode) {1343 result->clean = 0;1344 result->merge = 1;1345 }1346 }13471348 if (oid_eq(&a->oid, &b->oid) || oid_eq(&a->oid, &one->oid))1349 oidcpy(&result->oid, &b->oid);1350 else if (oid_eq(&b->oid, &one->oid))1351 oidcpy(&result->oid, &a->oid);1352 else if (S_ISREG(a->mode)) {1353 mmbuffer_t result_buf;1354 int ret = 0, merge_status;13551356 merge_status = merge_3way(o, &result_buf, one, a, b,1357 branch1, branch2,1358 extra_marker_size);13591360 if ((merge_status < 0) || !result_buf.ptr)1361 ret = err(o, _("Failed to execute internal merge"));13621363 if (!ret &&1364 write_object_file(result_buf.ptr, result_buf.size,1365 blob_type, &result->oid))1366 ret = err(o, _("Unable to add %s to database"),1367 a->path);13681369 free(result_buf.ptr);1370 if (ret)1371 return ret;1372 result->clean = (merge_status == 0);1373 } else if (S_ISGITLINK(a->mode)) {1374 result->clean = merge_submodule(o, &result->oid,1375 one->path,1376 &one->oid,1377 &a->oid,1378 &b->oid);1379 } else if (S_ISLNK(a->mode)) {1380 switch (o->recursive_variant) {1381 case MERGE_RECURSIVE_NORMAL:1382 oidcpy(&result->oid, &a->oid);1383 if (!oid_eq(&a->oid, &b->oid))1384 result->clean = 0;1385 break;1386 case MERGE_RECURSIVE_OURS:1387 oidcpy(&result->oid, &a->oid);1388 break;1389 case MERGE_RECURSIVE_THEIRS:1390 oidcpy(&result->oid, &b->oid);1391 break;1392 }1393 } else1394 BUG("unsupported object type in the tree");1395 }13961397 if (result->merge)1398 output(o, 2, _("Auto-merging %s"), filename);13991400 return 0;1401}14021403static int handle_rename_via_dir(struct merge_options *o,1404 struct diff_filepair *pair,1405 const char *rename_branch,1406 const char *other_branch)1407{1408 /*1409 * Handle file adds that need to be renamed due to directory rename1410 * detection. This differs from handle_rename_normal, because1411 * there is no content merge to do; just move the file into the1412 * desired final location.1413 */1414 const struct diff_filespec *dest = pair->two;14151416 if (!o->call_depth && would_lose_untracked(o, dest->path)) {1417 char *alt_path = unique_path(o, dest->path, rename_branch);14181419 output(o, 1, _("Error: Refusing to lose untracked file at %s; "1420 "writing to %s instead."),1421 dest->path, alt_path);1422 /*1423 * Write the file in worktree at alt_path, but not in the1424 * index. Instead, write to dest->path for the index but1425 * only at the higher appropriate stage.1426 */1427 if (update_file(o, 0, &dest->oid, dest->mode, alt_path))1428 return -1;1429 free(alt_path);1430 return update_stages(o, dest->path, NULL,1431 rename_branch == o->branch1 ? dest : NULL,1432 rename_branch == o->branch1 ? NULL : dest);1433 }14341435 /* Update dest->path both in index and in worktree */1436 if (update_file(o, 1, &dest->oid, dest->mode, dest->path))1437 return -1;1438 return 0;1439}14401441static int handle_change_delete(struct merge_options *o,1442 const char *path, const char *old_path,1443 const struct object_id *o_oid, int o_mode,1444 const struct object_id *changed_oid,1445 int changed_mode,1446 const char *change_branch,1447 const char *delete_branch,1448 const char *change, const char *change_past)1449{1450 char *alt_path = NULL;1451 const char *update_path = path;1452 int ret = 0;14531454 if (dir_in_way(o->repo->index, path, !o->call_depth, 0) ||1455 (!o->call_depth && would_lose_untracked(o, path))) {1456 update_path = alt_path = unique_path(o, path, change_branch);1457 }14581459 if (o->call_depth) {1460 /*1461 * We cannot arbitrarily accept either a_sha or b_sha as1462 * correct; since there is no true "middle point" between1463 * them, simply reuse the base version for virtual merge base.1464 */1465 ret = remove_file_from_index(o->repo->index, path);1466 if (!ret)1467 ret = update_file(o, 0, o_oid, o_mode, update_path);1468 } else {1469 /*1470 * Despite the four nearly duplicate messages and argument1471 * lists below and the ugliness of the nested if-statements,1472 * having complete messages makes the job easier for1473 * translators.1474 *1475 * The slight variance among the cases is due to the fact1476 * that:1477 * 1) directory/file conflicts (in effect if1478 * !alt_path) could cause us to need to write the1479 * file to a different path.1480 * 2) renames (in effect if !old_path) could mean that1481 * there are two names for the path that the user1482 * may know the file by.1483 */1484 if (!alt_path) {1485 if (!old_path) {1486 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "1487 "and %s in %s. Version %s of %s left in tree."),1488 change, path, delete_branch, change_past,1489 change_branch, change_branch, path);1490 } else {1491 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "1492 "and %s to %s in %s. Version %s of %s left in tree."),1493 change, old_path, delete_branch, change_past, path,1494 change_branch, change_branch, path);1495 }1496 } else {1497 if (!old_path) {1498 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "1499 "and %s in %s. Version %s of %s left in tree at %s."),1500 change, path, delete_branch, change_past,1501 change_branch, change_branch, path, alt_path);1502 } else {1503 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "1504 "and %s to %s in %s. Version %s of %s left in tree at %s."),1505 change, old_path, delete_branch, change_past, path,1506 change_branch, change_branch, path, alt_path);1507 }1508 }1509 /*1510 * No need to call update_file() on path when change_branch ==1511 * o->branch1 && !alt_path, since that would needlessly touch1512 * path. We could call update_file_flags() with update_cache=01513 * and update_wd=0, but that's a no-op.1514 */1515 if (change_branch != o->branch1 || alt_path)1516 ret = update_file(o, 0, changed_oid, changed_mode, update_path);1517 }1518 free(alt_path);15191520 return ret;1521}15221523static int handle_rename_delete(struct merge_options *o,1524 struct diff_filepair *pair,1525 const char *rename_branch,1526 const char *delete_branch)1527{1528 const struct diff_filespec *orig = pair->one;1529 const struct diff_filespec *dest = pair->two;15301531 if (handle_change_delete(o,1532 o->call_depth ? orig->path : dest->path,1533 o->call_depth ? NULL : orig->path,1534 &orig->oid, orig->mode,1535 &dest->oid, dest->mode,1536 rename_branch, delete_branch,1537 _("rename"), _("renamed")))1538 return -1;15391540 if (o->call_depth)1541 return remove_file_from_index(o->repo->index, dest->path);1542 else1543 return update_stages(o, dest->path, NULL,1544 rename_branch == o->branch1 ? dest : NULL,1545 rename_branch == o->branch1 ? NULL : dest);1546}15471548static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,1549 struct stage_data *entry,1550 int stage)1551{1552 struct object_id *oid = &entry->stages[stage].oid;1553 unsigned mode = entry->stages[stage].mode;1554 if (mode == 0 || is_null_oid(oid))1555 return NULL;1556 oidcpy(&target->oid, oid);1557 target->mode = mode;1558 return target;1559}15601561static int handle_file_collision(struct merge_options *o,1562 const char *collide_path,1563 const char *prev_path1,1564 const char *prev_path2,1565 const char *branch1, const char *branch2,1566 const struct object_id *a_oid,1567 unsigned int a_mode,1568 const struct object_id *b_oid,1569 unsigned int b_mode)1570{1571 struct merge_file_info mfi;1572 struct diff_filespec null, a, b;1573 char *alt_path = NULL;1574 const char *update_path = collide_path;15751576 /*1577 * It's easiest to get the correct things into stage 2 and 3, and1578 * to make sure that the content merge puts HEAD before the other1579 * branch if we just ensure that branch1 == o->branch1. So, simply1580 * flip arguments around if we don't have that.1581 */1582 if (branch1 != o->branch1) {1583 return handle_file_collision(o, collide_path,1584 prev_path2, prev_path1,1585 branch2, branch1,1586 b_oid, b_mode,1587 a_oid, a_mode);1588 }15891590 /*1591 * In the recursive case, we just opt to undo renames1592 */1593 if (o->call_depth && (prev_path1 || prev_path2)) {1594 /* Put first file (a_oid, a_mode) in its original spot */1595 if (prev_path1) {1596 if (update_file(o, 1, a_oid, a_mode, prev_path1))1597 return -1;1598 } else {1599 if (update_file(o, 1, a_oid, a_mode, collide_path))1600 return -1;1601 }16021603 /* Put second file (b_oid, b_mode) in its original spot */1604 if (prev_path2) {1605 if (update_file(o, 1, b_oid, b_mode, prev_path2))1606 return -1;1607 } else {1608 if (update_file(o, 1, b_oid, b_mode, collide_path))1609 return -1;1610 }16111612 /* Don't leave something at collision path if unrenaming both */1613 if (prev_path1 && prev_path2)1614 remove_file(o, 1, collide_path, 0);16151616 return 0;1617 }16181619 /* Remove rename sources if rename/add or rename/rename(2to1) */1620 if (prev_path1)1621 remove_file(o, 1, prev_path1,1622 o->call_depth || would_lose_untracked(o, prev_path1));1623 if (prev_path2)1624 remove_file(o, 1, prev_path2,1625 o->call_depth || would_lose_untracked(o, prev_path2));16261627 /*1628 * Remove the collision path, if it wouldn't cause dirty contents1629 * or an untracked file to get lost. We'll either overwrite with1630 * merged contents, or just write out to differently named files.1631 */1632 if (was_dirty(o, collide_path)) {1633 output(o, 1, _("Refusing to lose dirty file at %s"),1634 collide_path);1635 update_path = alt_path = unique_path(o, collide_path, "merged");1636 } else if (would_lose_untracked(o, collide_path)) {1637 /*1638 * Only way we get here is if both renames were from1639 * a directory rename AND user had an untracked file1640 * at the location where both files end up after the1641 * two directory renames. See testcase 10d of t6043.1642 */1643 output(o, 1, _("Refusing to lose untracked file at "1644 "%s, even though it's in the way."),1645 collide_path);1646 update_path = alt_path = unique_path(o, collide_path, "merged");1647 } else {1648 /*1649 * FIXME: It's possible that the two files are identical1650 * and that the current working copy happens to match, in1651 * which case we are unnecessarily touching the working1652 * tree file. It's not a likely enough scenario that I1653 * want to code up the checks for it and a better fix is1654 * available if we restructure how unpack_trees() and1655 * merge-recursive interoperate anyway, so punting for1656 * now...1657 */1658 remove_file(o, 0, collide_path, 0);1659 }16601661 /* Store things in diff_filespecs for functions that need it */1662 memset(&a, 0, sizeof(struct diff_filespec));1663 memset(&b, 0, sizeof(struct diff_filespec));1664 null.path = a.path = b.path = (char *)collide_path;1665 oidcpy(&null.oid, &null_oid);1666 null.mode = 0;1667 oidcpy(&a.oid, a_oid);1668 a.mode = a_mode;1669 a.oid_valid = 1;1670 oidcpy(&b.oid, b_oid);1671 b.mode = b_mode;1672 b.oid_valid = 1;16731674 if (merge_mode_and_contents(o, &null, &a, &b, collide_path,1675 branch1, branch2, o->call_depth * 2, &mfi))1676 return -1;1677 mfi.clean &= !alt_path;1678 if (update_file(o, mfi.clean, &mfi.oid, mfi.mode, update_path))1679 return -1;1680 if (!mfi.clean && !o->call_depth &&1681 update_stages(o, collide_path, NULL, &a, &b))1682 return -1;1683 free(alt_path);1684 /*1685 * FIXME: If both a & b both started with conflicts (only possible1686 * if they came from a rename/rename(2to1)), but had IDENTICAL1687 * contents including those conflicts, then in the next line we claim1688 * it was clean. If someone cares about this case, we should have the1689 * caller notify us if we started with conflicts.1690 */1691 return mfi.clean;1692}16931694static int handle_rename_add(struct merge_options *o,1695 struct rename_conflict_info *ci)1696{1697 /* a was renamed to c, and a separate c was added. */1698 struct diff_filespec *a = ci->pair1->one;1699 struct diff_filespec *c = ci->pair1->two;1700 char *path = c->path;1701 char *prev_path_desc;1702 struct merge_file_info mfi;17031704 int other_stage = (ci->branch1 == o->branch1 ? 3 : 2);17051706 output(o, 1, _("CONFLICT (rename/add): "1707 "Rename %s->%s in %s. Added %s in %s"),1708 a->path, c->path, ci->branch1,1709 c->path, ci->branch2);17101711 prev_path_desc = xstrfmt("version of %s from %s", path, a->path);1712 if (merge_mode_and_contents(o, a, c, &ci->ren1_other, prev_path_desc,1713 o->branch1, o->branch2,1714 1 + o->call_depth * 2, &mfi))1715 return -1;1716 free(prev_path_desc);17171718 return handle_file_collision(o,1719 c->path, a->path, NULL,1720 ci->branch1, ci->branch2,1721 &mfi.oid, mfi.mode,1722 &ci->dst_entry1->stages[other_stage].oid,1723 ci->dst_entry1->stages[other_stage].mode);1724}17251726static char *find_path_for_conflict(struct merge_options *o,1727 const char *path,1728 const char *branch1,1729 const char *branch2)1730{1731 char *new_path = NULL;1732 if (dir_in_way(o->repo->index, path, !o->call_depth, 0)) {1733 new_path = unique_path(o, path, branch1);1734 output(o, 1, _("%s is a directory in %s adding "1735 "as %s instead"),1736 path, branch2, new_path);1737 } else if (would_lose_untracked(o, path)) {1738 new_path = unique_path(o, path, branch1);1739 output(o, 1, _("Refusing to lose untracked file"1740 " at %s; adding as %s instead"),1741 path, new_path);1742 }17431744 return new_path;1745}17461747static int handle_rename_rename_1to2(struct merge_options *o,1748 struct rename_conflict_info *ci)1749{1750 /* One file was renamed in both branches, but to different names. */1751 struct merge_file_info mfi;1752 struct diff_filespec other;1753 struct diff_filespec *add;1754 struct diff_filespec *one = ci->pair1->one;1755 struct diff_filespec *a = ci->pair1->two;1756 struct diff_filespec *b = ci->pair2->two;1757 char *path_desc;17581759 output(o, 1, _("CONFLICT (rename/rename): "1760 "Rename \"%s\"->\"%s\" in branch \"%s\" "1761 "rename \"%s\"->\"%s\" in \"%s\"%s"),1762 one->path, a->path, ci->branch1,1763 one->path, b->path, ci->branch2,1764 o->call_depth ? _(" (left unresolved)") : "");17651766 path_desc = xstrfmt("%s and %s, both renamed from %s",1767 a->path, b->path, one->path);1768 if (merge_mode_and_contents(o, one, a, b, path_desc,1769 ci->branch1, ci->branch2,1770 o->call_depth * 2, &mfi))1771 return -1;1772 free(path_desc);17731774 if (o->call_depth) {1775 /*1776 * FIXME: For rename/add-source conflicts (if we could detect1777 * such), this is wrong. We should instead find a unique1778 * pathname and then either rename the add-source file to that1779 * unique path, or use that unique path instead of src here.1780 */1781 if (update_file(o, 0, &mfi.oid, mfi.mode, one->path))1782 return -1;17831784 /*1785 * Above, we put the merged content at the merge-base's1786 * path. Now we usually need to delete both a->path and1787 * b->path. However, the rename on each side of the merge1788 * could also be involved in a rename/add conflict. In1789 * such cases, we should keep the added file around,1790 * resolving the conflict at that path in its favor.1791 */1792 add = filespec_from_entry(&other, ci->dst_entry1, 2 ^ 1);1793 if (add) {1794 if (update_file(o, 0, &add->oid, add->mode, a->path))1795 return -1;1796 }1797 else1798 remove_file_from_index(o->repo->index, a->path);1799 add = filespec_from_entry(&other, ci->dst_entry2, 3 ^ 1);1800 if (add) {1801 if (update_file(o, 0, &add->oid, add->mode, b->path))1802 return -1;1803 }1804 else1805 remove_file_from_index(o->repo->index, b->path);1806 } else {1807 /*1808 * For each destination path, we need to see if there is a1809 * rename/add collision. If not, we can write the file out1810 * to the specified location.1811 */1812 add = filespec_from_entry(&other, ci->dst_entry1, 2 ^ 1);1813 if (add) {1814 if (handle_file_collision(o, a->path,1815 NULL, NULL,1816 ci->branch1, ci->branch2,1817 &mfi.oid, mfi.mode,1818 &add->oid, add->mode) < 0)1819 return -1;1820 } else {1821 char *new_path = find_path_for_conflict(o, a->path,1822 ci->branch1,1823 ci->branch2);1824 if (update_file(o, 0, &mfi.oid, mfi.mode, new_path ? new_path : a->path))1825 return -1;1826 free(new_path);1827 if (update_stages(o, a->path, NULL, a, NULL))1828 return -1;1829 }18301831 add = filespec_from_entry(&other, ci->dst_entry2, 3 ^ 1);1832 if (add) {1833 if (handle_file_collision(o, b->path,1834 NULL, NULL,1835 ci->branch1, ci->branch2,1836 &add->oid, add->mode,1837 &mfi.oid, mfi.mode) < 0)1838 return -1;1839 } else {1840 char *new_path = find_path_for_conflict(o, b->path,1841 ci->branch2,1842 ci->branch1);1843 if (update_file(o, 0, &mfi.oid, mfi.mode, new_path ? new_path : b->path))1844 return -1;1845 free(new_path);1846 if (update_stages(o, b->path, NULL, NULL, b))1847 return -1;1848 }1849 }18501851 return 0;1852}18531854static int handle_rename_rename_2to1(struct merge_options *o,1855 struct rename_conflict_info *ci)1856{1857 /* Two files, a & b, were renamed to the same thing, c. */1858 struct diff_filespec *a = ci->pair1->one;1859 struct diff_filespec *b = ci->pair2->one;1860 struct diff_filespec *c1 = ci->pair1->two;1861 struct diff_filespec *c2 = ci->pair2->two;1862 char *path = c1->path; /* == c2->path */1863 char *path_side_1_desc;1864 char *path_side_2_desc;1865 struct merge_file_info mfi_c1;1866 struct merge_file_info mfi_c2;18671868 output(o, 1, _("CONFLICT (rename/rename): "1869 "Rename %s->%s in %s. "1870 "Rename %s->%s in %s"),1871 a->path, c1->path, ci->branch1,1872 b->path, c2->path, ci->branch2);18731874 path_side_1_desc = xstrfmt("version of %s from %s", path, a->path);1875 path_side_2_desc = xstrfmt("version of %s from %s", path, b->path);1876 if (merge_mode_and_contents(o, a, c1, &ci->ren1_other, path_side_1_desc,1877 o->branch1, o->branch2,1878 1 + o->call_depth * 2, &mfi_c1) ||1879 merge_mode_and_contents(o, b, &ci->ren2_other, c2, path_side_2_desc,1880 o->branch1, o->branch2,1881 1 + o->call_depth * 2, &mfi_c2))1882 return -1;1883 free(path_side_1_desc);1884 free(path_side_2_desc);18851886 return handle_file_collision(o, path, a->path, b->path,1887 ci->branch1, ci->branch2,1888 &mfi_c1.oid, mfi_c1.mode,1889 &mfi_c2.oid, mfi_c2.mode);1890}18911892/*1893 * Get the diff_filepairs changed between o_tree and tree.1894 */1895static struct diff_queue_struct *get_diffpairs(struct merge_options *o,1896 struct tree *o_tree,1897 struct tree *tree)1898{1899 struct diff_queue_struct *ret;1900 struct diff_options opts;19011902 repo_diff_setup(o->repo, &opts);1903 opts.flags.recursive = 1;1904 opts.flags.rename_empty = 0;1905 opts.detect_rename = merge_detect_rename(o);1906 /*1907 * We do not have logic to handle the detection of copies. In1908 * fact, it may not even make sense to add such logic: would we1909 * really want a change to a base file to be propagated through1910 * multiple other files by a merge?1911 */1912 if (opts.detect_rename > DIFF_DETECT_RENAME)1913 opts.detect_rename = DIFF_DETECT_RENAME;1914 opts.rename_limit = o->merge_rename_limit >= 0 ? o->merge_rename_limit :1915 o->diff_rename_limit >= 0 ? o->diff_rename_limit :1916 1000;1917 opts.rename_score = o->rename_score;1918 opts.show_rename_progress = o->show_rename_progress;1919 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1920 diff_setup_done(&opts);1921 diff_tree_oid(&o_tree->object.oid, &tree->object.oid, "", &opts);1922 diffcore_std(&opts);1923 if (opts.needed_rename_limit > o->needed_rename_limit)1924 o->needed_rename_limit = opts.needed_rename_limit;19251926 ret = xmalloc(sizeof(*ret));1927 *ret = diff_queued_diff;19281929 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1930 diff_queued_diff.nr = 0;1931 diff_queued_diff.queue = NULL;1932 diff_flush(&opts);1933 return ret;1934}19351936static int tree_has_path(struct tree *tree, const char *path)1937{1938 struct object_id hashy;1939 unsigned int mode_o;19401941 return !get_tree_entry(&tree->object.oid, path,1942 &hashy, &mode_o);1943}19441945/*1946 * Return a new string that replaces the beginning portion (which matches1947 * entry->dir), with entry->new_dir. In perl-speak:1948 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1949 * NOTE:1950 * Caller must ensure that old_path starts with entry->dir + '/'.1951 */1952static char *apply_dir_rename(struct dir_rename_entry *entry,1953 const char *old_path)1954{1955 struct strbuf new_path = STRBUF_INIT;1956 int oldlen, newlen;19571958 if (entry->non_unique_new_dir)1959 return NULL;19601961 oldlen = strlen(entry->dir);1962 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) + 1;1963 strbuf_grow(&new_path, newlen);1964 strbuf_addbuf(&new_path, &entry->new_dir);1965 strbuf_addstr(&new_path, &old_path[oldlen]);19661967 return strbuf_detach(&new_path, NULL);1968}19691970static void get_renamed_dir_portion(const char *old_path, const char *new_path,1971 char **old_dir, char **new_dir)1972{1973 char *end_of_old, *end_of_new;1974 int old_len, new_len;19751976 *old_dir = NULL;1977 *new_dir = NULL;19781979 /*1980 * For1981 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1982 * the "e/foo.c" part is the same, we just want to know that1983 * "a/b/c/d" was renamed to "a/b/some/thing/else"1984 * so, for this example, this function returns "a/b/c/d" in1985 * *old_dir and "a/b/some/thing/else" in *new_dir.1986 *1987 * Also, if the basename of the file changed, we don't care. We1988 * want to know which portion of the directory, if any, changed.1989 */1990 end_of_old = strrchr(old_path, '/');1991 end_of_new = strrchr(new_path, '/');19921993 if (end_of_old == NULL || end_of_new == NULL)1994 return;1995 while (*--end_of_new == *--end_of_old &&1996 end_of_old != old_path &&1997 end_of_new != new_path)1998 ; /* Do nothing; all in the while loop */1999 /*2000 * We've found the first non-matching character in the directory2001 * paths. That means the current directory we were comparing2002 * represents the rename. Move end_of_old and end_of_new back2003 * to the full directory name.2004 */2005 if (*end_of_old == '/')2006 end_of_old++;2007 if (*end_of_old != '/')2008 end_of_new++;2009 end_of_old = strchr(end_of_old, '/');2010 end_of_new = strchr(end_of_new, '/');20112012 /*2013 * It may have been the case that old_path and new_path were the same2014 * directory all along. Don't claim a rename if they're the same.2015 */2016 old_len = end_of_old - old_path;2017 new_len = end_of_new - new_path;20182019 if (old_len != new_len || strncmp(old_path, new_path, old_len)) {2020 *old_dir = xstrndup(old_path, old_len);2021 *new_dir = xstrndup(new_path, new_len);2022 }2023}20242025static void remove_hashmap_entries(struct hashmap *dir_renames,2026 struct string_list *items_to_remove)2027{2028 int i;2029 struct dir_rename_entry *entry;20302031 for (i = 0; i < items_to_remove->nr; i++) {2032 entry = items_to_remove->items[i].util;2033 hashmap_remove(dir_renames, entry, NULL);2034 }2035 string_list_clear(items_to_remove, 0);2036}20372038/*2039 * See if there is a directory rename for path, and if there are any file2040 * level conflicts for the renamed location. If there is a rename and2041 * there are no conflicts, return the new name. Otherwise, return NULL.2042 */2043static char *handle_path_level_conflicts(struct merge_options *o,2044 const char *path,2045 struct dir_rename_entry *entry,2046 struct hashmap *collisions,2047 struct tree *tree)2048{2049 char *new_path = NULL;2050 struct collision_entry *collision_ent;2051 int clean = 1;2052 struct strbuf collision_paths = STRBUF_INIT;20532054 /*2055 * entry has the mapping of old directory name to new directory name2056 * that we want to apply to path.2057 */2058 new_path = apply_dir_rename(entry, path);20592060 if (!new_path) {2061 /* This should only happen when entry->non_unique_new_dir set */2062 if (!entry->non_unique_new_dir)2063 BUG("entry->non_unqiue_dir not set and !new_path");2064 output(o, 1, _("CONFLICT (directory rename split): "2065 "Unclear where to place %s because directory "2066 "%s was renamed to multiple other directories, "2067 "with no destination getting a majority of the "2068 "files."),2069 path, entry->dir);2070 clean = 0;2071 return NULL;2072 }20732074 /*2075 * The caller needs to have ensured that it has pre-populated2076 * collisions with all paths that map to new_path. Do a quick check2077 * to ensure that's the case.2078 */2079 collision_ent = collision_find_entry(collisions, new_path);2080 if (collision_ent == NULL)2081 BUG("collision_ent is NULL");20822083 /*2084 * Check for one-sided add/add/.../add conflicts, i.e.2085 * where implicit renames from the other side doing2086 * directory rename(s) can affect this side of history2087 * to put multiple paths into the same location. Warn2088 * and bail on directory renames for such paths.2089 */2090 if (collision_ent->reported_already) {2091 clean = 0;2092 } else if (tree_has_path(tree, new_path)) {2093 collision_ent->reported_already = 1;2094 strbuf_add_separated_string_list(&collision_paths, ", ",2095 &collision_ent->source_files);2096 output(o, 1, _("CONFLICT (implicit dir rename): Existing "2097 "file/dir at %s in the way of implicit "2098 "directory rename(s) putting the following "2099 "path(s) there: %s."),2100 new_path, collision_paths.buf);2101 clean = 0;2102 } else if (collision_ent->source_files.nr > 1) {2103 collision_ent->reported_already = 1;2104 strbuf_add_separated_string_list(&collision_paths, ", ",2105 &collision_ent->source_files);2106 output(o, 1, _("CONFLICT (implicit dir rename): Cannot map "2107 "more than one path to %s; implicit directory "2108 "renames tried to put these paths there: %s"),2109 new_path, collision_paths.buf);2110 clean = 0;2111 }21122113 /* Free memory we no longer need */2114 strbuf_release(&collision_paths);2115 if (!clean && new_path) {2116 free(new_path);2117 return NULL;2118 }21192120 return new_path;2121}21222123/*2124 * There are a couple things we want to do at the directory level:2125 * 1. Check for both sides renaming to the same thing, in order to avoid2126 * implicit renaming of files that should be left in place. (See2127 * testcase 6b in t6043 for details.)2128 * 2. Prune directory renames if there are still files left in the2129 * the original directory. These represent a partial directory rename,2130 * i.e. a rename where only some of the files within the directory2131 * were renamed elsewhere. (Technically, this could be done earlier2132 * in get_directory_renames(), except that would prevent us from2133 * doing the previous check and thus failing testcase 6b.)2134 * 3. Check for rename/rename(1to2) conflicts (at the directory level).2135 * In the future, we could potentially record this info as well and2136 * omit reporting rename/rename(1to2) conflicts for each path within2137 * the affected directories, thus cleaning up the merge output.2138 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the2139 * directory level, because merging directories is fine. If it2140 * causes conflicts for files within those merged directories, then2141 * that should be detected at the individual path level.2142 */2143static void handle_directory_level_conflicts(struct merge_options *o,2144 struct hashmap *dir_re_head,2145 struct tree *head,2146 struct hashmap *dir_re_merge,2147 struct tree *merge)2148{2149 struct hashmap_iter iter;2150 struct dir_rename_entry *head_ent;2151 struct dir_rename_entry *merge_ent;21522153 struct string_list remove_from_head = STRING_LIST_INIT_NODUP;2154 struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;21552156 hashmap_iter_init(dir_re_head, &iter);2157 while ((head_ent = hashmap_iter_next(&iter))) {2158 merge_ent = dir_rename_find_entry(dir_re_merge, head_ent->dir);2159 if (merge_ent &&2160 !head_ent->non_unique_new_dir &&2161 !merge_ent->non_unique_new_dir &&2162 !strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {2163 /* 1. Renamed identically; remove it from both sides */2164 string_list_append(&remove_from_head,2165 head_ent->dir)->util = head_ent;2166 strbuf_release(&head_ent->new_dir);2167 string_list_append(&remove_from_merge,2168 merge_ent->dir)->util = merge_ent;2169 strbuf_release(&merge_ent->new_dir);2170 } else if (tree_has_path(head, head_ent->dir)) {2171 /* 2. This wasn't a directory rename after all */2172 string_list_append(&remove_from_head,2173 head_ent->dir)->util = head_ent;2174 strbuf_release(&head_ent->new_dir);2175 }2176 }21772178 remove_hashmap_entries(dir_re_head, &remove_from_head);2179 remove_hashmap_entries(dir_re_merge, &remove_from_merge);21802181 hashmap_iter_init(dir_re_merge, &iter);2182 while ((merge_ent = hashmap_iter_next(&iter))) {2183 head_ent = dir_rename_find_entry(dir_re_head, merge_ent->dir);2184 if (tree_has_path(merge, merge_ent->dir)) {2185 /* 2. This wasn't a directory rename after all */2186 string_list_append(&remove_from_merge,2187 merge_ent->dir)->util = merge_ent;2188 } else if (head_ent &&2189 !head_ent->non_unique_new_dir &&2190 !merge_ent->non_unique_new_dir) {2191 /* 3. rename/rename(1to2) */2192 /*2193 * We can assume it's not rename/rename(1to1) because2194 * that was case (1), already checked above. So we2195 * know that head_ent->new_dir and merge_ent->new_dir2196 * are different strings.2197 */2198 output(o, 1, _("CONFLICT (rename/rename): "2199 "Rename directory %s->%s in %s. "2200 "Rename directory %s->%s in %s"),2201 head_ent->dir, head_ent->new_dir.buf, o->branch1,2202 head_ent->dir, merge_ent->new_dir.buf, o->branch2);2203 string_list_append(&remove_from_head,2204 head_ent->dir)->util = head_ent;2205 strbuf_release(&head_ent->new_dir);2206 string_list_append(&remove_from_merge,2207 merge_ent->dir)->util = merge_ent;2208 strbuf_release(&merge_ent->new_dir);2209 }2210 }22112212 remove_hashmap_entries(dir_re_head, &remove_from_head);2213 remove_hashmap_entries(dir_re_merge, &remove_from_merge);2214}22152216static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,2217 struct tree *tree)2218{2219 struct hashmap *dir_renames;2220 struct hashmap_iter iter;2221 struct dir_rename_entry *entry;2222 int i;22232224 /*2225 * Typically, we think of a directory rename as all files from a2226 * certain directory being moved to a target directory. However,2227 * what if someone first moved two files from the original2228 * directory in one commit, and then renamed the directory2229 * somewhere else in a later commit? At merge time, we just know2230 * that files from the original directory went to two different2231 * places, and that the bulk of them ended up in the same place.2232 * We want each directory rename to represent where the bulk of the2233 * files from that directory end up; this function exists to find2234 * where the bulk of the files went.2235 *2236 * The first loop below simply iterates through the list of file2237 * renames, finding out how often each directory rename pair2238 * possibility occurs.2239 */2240 dir_renames = xmalloc(sizeof(*dir_renames));2241 dir_rename_init(dir_renames);2242 for (i = 0; i < pairs->nr; ++i) {2243 struct string_list_item *item;2244 int *count;2245 struct diff_filepair *pair = pairs->queue[i];2246 char *old_dir, *new_dir;22472248 /* File not part of directory rename if it wasn't renamed */2249 if (pair->status != 'R')2250 continue;22512252 get_renamed_dir_portion(pair->one->path, pair->two->path,2253 &old_dir, &new_dir);2254 if (!old_dir)2255 /* Directory didn't change at all; ignore this one. */2256 continue;22572258 entry = dir_rename_find_entry(dir_renames, old_dir);2259 if (!entry) {2260 entry = xmalloc(sizeof(*entry));2261 dir_rename_entry_init(entry, old_dir);2262 hashmap_put(dir_renames, entry);2263 } else {2264 free(old_dir);2265 }2266 item = string_list_lookup(&entry->possible_new_dirs, new_dir);2267 if (!item) {2268 item = string_list_insert(&entry->possible_new_dirs,2269 new_dir);2270 item->util = xcalloc(1, sizeof(int));2271 } else {2272 free(new_dir);2273 }2274 count = item->util;2275 *count += 1;2276 }22772278 /*2279 * For each directory with files moved out of it, we find out which2280 * target directory received the most files so we can declare it to2281 * be the "winning" target location for the directory rename. This2282 * winner gets recorded in new_dir. If there is no winner2283 * (multiple target directories received the same number of files),2284 * we set non_unique_new_dir. Once we've determined the winner (or2285 * that there is no winner), we no longer need possible_new_dirs.2286 */2287 hashmap_iter_init(dir_renames, &iter);2288 while ((entry = hashmap_iter_next(&iter))) {2289 int max = 0;2290 int bad_max = 0;2291 char *best = NULL;22922293 for (i = 0; i < entry->possible_new_dirs.nr; i++) {2294 int *count = entry->possible_new_dirs.items[i].util;22952296 if (*count == max)2297 bad_max = max;2298 else if (*count > max) {2299 max = *count;2300 best = entry->possible_new_dirs.items[i].string;2301 }2302 }2303 if (bad_max == max)2304 entry->non_unique_new_dir = 1;2305 else {2306 assert(entry->new_dir.len == 0);2307 strbuf_addstr(&entry->new_dir, best);2308 }2309 /*2310 * The relevant directory sub-portion of the original full2311 * filepaths were xstrndup'ed before inserting into2312 * possible_new_dirs, and instead of manually iterating the2313 * list and free'ing each, just lie and tell2314 * possible_new_dirs that it did the strdup'ing so that it2315 * will free them for us.2316 */2317 entry->possible_new_dirs.strdup_strings = 1;2318 string_list_clear(&entry->possible_new_dirs, 1);2319 }23202321 return dir_renames;2322}23232324static struct dir_rename_entry *check_dir_renamed(const char *path,2325 struct hashmap *dir_renames)2326{2327 char *temp = xstrdup(path);2328 char *end;2329 struct dir_rename_entry *entry = NULL;23302331 while ((end = strrchr(temp, '/'))) {2332 *end = '\0';2333 entry = dir_rename_find_entry(dir_renames, temp);2334 if (entry)2335 break;2336 }2337 free(temp);2338 return entry;2339}23402341static void compute_collisions(struct hashmap *collisions,2342 struct hashmap *dir_renames,2343 struct diff_queue_struct *pairs)2344{2345 int i;23462347 /*2348 * Multiple files can be mapped to the same path due to directory2349 * renames done by the other side of history. Since that other2350 * side of history could have merged multiple directories into one,2351 * if our side of history added the same file basename to each of2352 * those directories, then all N of them would get implicitly2353 * renamed by the directory rename detection into the same path,2354 * and we'd get an add/add/.../add conflict, and all those adds2355 * from *this* side of history. This is not representable in the2356 * index, and users aren't going to easily be able to make sense of2357 * it. So we need to provide a good warning about what's2358 * happening, and fall back to no-directory-rename detection2359 * behavior for those paths.2360 *2361 * See testcases 9e and all of section 5 from t6043 for examples.2362 */2363 collision_init(collisions);23642365 for (i = 0; i < pairs->nr; ++i) {2366 struct dir_rename_entry *dir_rename_ent;2367 struct collision_entry *collision_ent;2368 char *new_path;2369 struct diff_filepair *pair = pairs->queue[i];23702371 if (pair->status != 'A' && pair->status != 'R')2372 continue;2373 dir_rename_ent = check_dir_renamed(pair->two->path,2374 dir_renames);2375 if (!dir_rename_ent)2376 continue;23772378 new_path = apply_dir_rename(dir_rename_ent, pair->two->path);2379 if (!new_path)2380 /*2381 * dir_rename_ent->non_unique_new_path is true, which2382 * means there is no directory rename for us to use,2383 * which means it won't cause us any additional2384 * collisions.2385 */2386 continue;2387 collision_ent = collision_find_entry(collisions, new_path);2388 if (!collision_ent) {2389 collision_ent = xcalloc(1,2390 sizeof(struct collision_entry));2391 hashmap_entry_init(collision_ent, strhash(new_path));2392 hashmap_put(collisions, collision_ent);2393 collision_ent->target_file = new_path;2394 } else {2395 free(new_path);2396 }2397 string_list_insert(&collision_ent->source_files,2398 pair->two->path);2399 }2400}24012402static char *check_for_directory_rename(struct merge_options *o,2403 const char *path,2404 struct tree *tree,2405 struct hashmap *dir_renames,2406 struct hashmap *dir_rename_exclusions,2407 struct hashmap *collisions,2408 int *clean_merge)2409{2410 char *new_path = NULL;2411 struct dir_rename_entry *entry = check_dir_renamed(path, dir_renames);2412 struct dir_rename_entry *oentry = NULL;24132414 if (!entry)2415 return new_path;24162417 /*2418 * This next part is a little weird. We do not want to do an2419 * implicit rename into a directory we renamed on our side, because2420 * that will result in a spurious rename/rename(1to2) conflict. An2421 * example:2422 * Base commit: dumbdir/afile, otherdir/bfile2423 * Side 1: smrtdir/afile, otherdir/bfile2424 * Side 2: dumbdir/afile, dumbdir/bfile2425 * Here, while working on Side 1, we could notice that otherdir was2426 * renamed/merged to dumbdir, and change the diff_filepair for2427 * otherdir/bfile into a rename into dumbdir/bfile. However, Side2428 * 2 will notice the rename from dumbdir to smrtdir, and do the2429 * transitive rename to move it from dumbdir/bfile to2430 * smrtdir/bfile. That gives us bfile in dumbdir vs being in2431 * smrtdir, a rename/rename(1to2) conflict. We really just want2432 * the file to end up in smrtdir. And the way to achieve that is2433 * to not let Side1 do the rename to dumbdir, since we know that is2434 * the source of one of our directory renames.2435 *2436 * That's why oentry and dir_rename_exclusions is here.2437 *2438 * As it turns out, this also prevents N-way transient rename2439 * confusion; See testcases 9c and 9d of t6043.2440 */2441 oentry = dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);2442 if (oentry) {2443 output(o, 1, _("WARNING: Avoiding applying %s -> %s rename "2444 "to %s, because %s itself was renamed."),2445 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);2446 } else {2447 new_path = handle_path_level_conflicts(o, path, entry,2448 collisions, tree);2449 *clean_merge &= (new_path != NULL);2450 }24512452 return new_path;2453}24542455static void apply_directory_rename_modifications(struct merge_options *o,2456 struct diff_filepair *pair,2457 char *new_path,2458 struct rename *re,2459 struct tree *tree,2460 struct tree *o_tree,2461 struct tree *a_tree,2462 struct tree *b_tree,2463 struct string_list *entries,2464 int *clean)2465{2466 struct string_list_item *item;2467 int stage = (tree == a_tree ? 2 : 3);2468 int update_wd;24692470 /*2471 * In all cases where we can do directory rename detection,2472 * unpack_trees() will have read pair->two->path into the2473 * index and the working copy. We need to remove it so that2474 * we can instead place it at new_path. It is guaranteed to2475 * not be untracked (unpack_trees() would have errored out2476 * saying the file would have been overwritten), but it might2477 * be dirty, though.2478 */2479 update_wd = !was_dirty(o, pair->two->path);2480 if (!update_wd)2481 output(o, 1, _("Refusing to lose dirty file at %s"),2482 pair->two->path);2483 remove_file(o, 1, pair->two->path, !update_wd);24842485 /* Find or create a new re->dst_entry */2486 item = string_list_lookup(entries, new_path);2487 if (item) {2488 /*2489 * Since we're renaming on this side of history, and it's2490 * due to a directory rename on the other side of history2491 * (which we only allow when the directory in question no2492 * longer exists on the other side of history), the2493 * original entry for re->dst_entry is no longer2494 * necessary...2495 */2496 re->dst_entry->processed = 1;24972498 /*2499 * ...because we'll be using this new one.2500 */2501 re->dst_entry = item->util;2502 } else {2503 /*2504 * re->dst_entry is for the before-dir-rename path, and we2505 * need it to hold information for the after-dir-rename2506 * path. Before creating a new entry, we need to mark the2507 * old one as unnecessary (...unless it is shared by2508 * src_entry, i.e. this didn't use to be a rename, in which2509 * case we can just allow the normal processing to happen2510 * for it).2511 */2512 if (pair->status == 'R')2513 re->dst_entry->processed = 1;25142515 re->dst_entry = insert_stage_data(new_path,2516 o_tree, a_tree, b_tree,2517 entries);2518 item = string_list_insert(entries, new_path);2519 item->util = re->dst_entry;2520 }25212522 /*2523 * Update the stage_data with the information about the path we are2524 * moving into place. That slot will be empty and available for us2525 * to write to because of the collision checks in2526 * handle_path_level_conflicts(). In other words,2527 * re->dst_entry->stages[stage].oid will be the null_oid, so it's2528 * open for us to write to.2529 *2530 * It may be tempting to actually update the index at this point as2531 * well, using update_stages_for_stage_data(), but as per the big2532 * "NOTE" in update_stages(), doing so will modify the current2533 * in-memory index which will break calls to would_lose_untracked()2534 * that we need to make. Instead, we need to just make sure that2535 * the various handle_rename_*() functions update the index2536 * explicitly rather than relying on unpack_trees() to have done it.2537 */2538 get_tree_entry(&tree->object.oid,2539 pair->two->path,2540 &re->dst_entry->stages[stage].oid,2541 &re->dst_entry->stages[stage].mode);25422543 /* Update pair status */2544 if (pair->status == 'A') {2545 /*2546 * Recording rename information for this add makes it look2547 * like a rename/delete conflict. Make sure we can2548 * correctly handle this as an add that was moved to a new2549 * directory instead of reporting a rename/delete conflict.2550 */2551 re->add_turned_into_rename = 1;2552 }2553 /*2554 * We don't actually look at pair->status again, but it seems2555 * pedagogically correct to adjust it.2556 */2557 pair->status = 'R';25582559 /*2560 * Finally, record the new location.2561 */2562 pair->two->path = new_path;2563}25642565/*2566 * Get information of all renames which occurred in 'pairs', making use of2567 * any implicit directory renames inferred from the other side of history.2568 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')2569 * to be able to associate the correct cache entries with the rename2570 * information; tree is always equal to either a_tree or b_tree.2571 */2572static struct string_list *get_renames(struct merge_options *o,2573 struct diff_queue_struct *pairs,2574 struct hashmap *dir_renames,2575 struct hashmap *dir_rename_exclusions,2576 struct tree *tree,2577 struct tree *o_tree,2578 struct tree *a_tree,2579 struct tree *b_tree,2580 struct string_list *entries,2581 int *clean_merge)2582{2583 int i;2584 struct hashmap collisions;2585 struct hashmap_iter iter;2586 struct collision_entry *e;2587 struct string_list *renames;25882589 compute_collisions(&collisions, dir_renames, pairs);2590 renames = xcalloc(1, sizeof(struct string_list));25912592 for (i = 0; i < pairs->nr; ++i) {2593 struct string_list_item *item;2594 struct rename *re;2595 struct diff_filepair *pair = pairs->queue[i];2596 char *new_path; /* non-NULL only with directory renames */25972598 if (pair->status != 'A' && pair->status != 'R') {2599 diff_free_filepair(pair);2600 continue;2601 }2602 new_path = check_for_directory_rename(o, pair->two->path, tree,2603 dir_renames,2604 dir_rename_exclusions,2605 &collisions,2606 clean_merge);2607 if (pair->status != 'R' && !new_path) {2608 diff_free_filepair(pair);2609 continue;2610 }26112612 re = xmalloc(sizeof(*re));2613 re->processed = 0;2614 re->add_turned_into_rename = 0;2615 re->pair = pair;2616 item = string_list_lookup(entries, re->pair->one->path);2617 if (!item)2618 re->src_entry = insert_stage_data(re->pair->one->path,2619 o_tree, a_tree, b_tree, entries);2620 else2621 re->src_entry = item->util;26222623 item = string_list_lookup(entries, re->pair->two->path);2624 if (!item)2625 re->dst_entry = insert_stage_data(re->pair->two->path,2626 o_tree, a_tree, b_tree, entries);2627 else2628 re->dst_entry = item->util;2629 item = string_list_insert(renames, pair->one->path);2630 item->util = re;2631 if (new_path)2632 apply_directory_rename_modifications(o, pair, new_path,2633 re, tree, o_tree,2634 a_tree, b_tree,2635 entries,2636 clean_merge);2637 }26382639 hashmap_iter_init(&collisions, &iter);2640 while ((e = hashmap_iter_next(&iter))) {2641 free(e->target_file);2642 string_list_clear(&e->source_files, 0);2643 }2644 hashmap_free(&collisions, 1);2645 return renames;2646}26472648static int process_renames(struct merge_options *o,2649 struct string_list *a_renames,2650 struct string_list *b_renames)2651{2652 int clean_merge = 1, i, j;2653 struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2654 struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2655 const struct rename *sre;26562657 for (i = 0; i < a_renames->nr; i++) {2658 sre = a_renames->items[i].util;2659 string_list_insert(&a_by_dst, sre->pair->two->path)->util2660 = (void *)sre;2661 }2662 for (i = 0; i < b_renames->nr; i++) {2663 sre = b_renames->items[i].util;2664 string_list_insert(&b_by_dst, sre->pair->two->path)->util2665 = (void *)sre;2666 }26672668 for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {2669 struct string_list *renames1, *renames2Dst;2670 struct rename *ren1 = NULL, *ren2 = NULL;2671 const char *branch1, *branch2;2672 const char *ren1_src, *ren1_dst;2673 struct string_list_item *lookup;26742675 if (i >= a_renames->nr) {2676 ren2 = b_renames->items[j++].util;2677 } else if (j >= b_renames->nr) {2678 ren1 = a_renames->items[i++].util;2679 } else {2680 int compare = strcmp(a_renames->items[i].string,2681 b_renames->items[j].string);2682 if (compare <= 0)2683 ren1 = a_renames->items[i++].util;2684 if (compare >= 0)2685 ren2 = b_renames->items[j++].util;2686 }26872688 /* TODO: refactor, so that 1/2 are not needed */2689 if (ren1) {2690 renames1 = a_renames;2691 renames2Dst = &b_by_dst;2692 branch1 = o->branch1;2693 branch2 = o->branch2;2694 } else {2695 renames1 = b_renames;2696 renames2Dst = &a_by_dst;2697 branch1 = o->branch2;2698 branch2 = o->branch1;2699 SWAP(ren2, ren1);2700 }27012702 if (ren1->processed)2703 continue;2704 ren1->processed = 1;2705 ren1->dst_entry->processed = 1;2706 /* BUG: We should only mark src_entry as processed if we2707 * are not dealing with a rename + add-source case.2708 */2709 ren1->src_entry->processed = 1;27102711 ren1_src = ren1->pair->one->path;2712 ren1_dst = ren1->pair->two->path;27132714 if (ren2) {2715 /* One file renamed on both sides */2716 const char *ren2_src = ren2->pair->one->path;2717 const char *ren2_dst = ren2->pair->two->path;2718 enum rename_type rename_type;2719 if (strcmp(ren1_src, ren2_src) != 0)2720 BUG("ren1_src != ren2_src");2721 ren2->dst_entry->processed = 1;2722 ren2->processed = 1;2723 if (strcmp(ren1_dst, ren2_dst) != 0) {2724 rename_type = RENAME_ONE_FILE_TO_TWO;2725 clean_merge = 0;2726 } else {2727 rename_type = RENAME_ONE_FILE_TO_ONE;2728 /* BUG: We should only remove ren1_src in2729 * the base stage (think of rename +2730 * add-source cases).2731 */2732 remove_file(o, 1, ren1_src, 1);2733 update_entry(ren1->dst_entry,2734 ren1->pair->one,2735 ren1->pair->two,2736 ren2->pair->two);2737 }2738 setup_rename_conflict_info(rename_type,2739 ren1->pair,2740 ren2->pair,2741 branch1,2742 branch2,2743 ren1->dst_entry,2744 ren2->dst_entry,2745 o,2746 NULL,2747 NULL);2748 } else if ((lookup = string_list_lookup(renames2Dst, ren1_dst))) {2749 /* Two different files renamed to the same thing */2750 char *ren2_dst;2751 ren2 = lookup->util;2752 ren2_dst = ren2->pair->two->path;2753 if (strcmp(ren1_dst, ren2_dst) != 0)2754 BUG("ren1_dst != ren2_dst");27552756 clean_merge = 0;2757 ren2->processed = 1;2758 /*2759 * BUG: We should only mark src_entry as processed2760 * if we are not dealing with a rename + add-source2761 * case.2762 */2763 ren2->src_entry->processed = 1;27642765 setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2766 ren1->pair,2767 ren2->pair,2768 branch1,2769 branch2,2770 ren1->dst_entry,2771 ren2->dst_entry,2772 o,2773 ren1->src_entry,2774 ren2->src_entry);27752776 } else {2777 /* Renamed in 1, maybe changed in 2 */2778 /* we only use sha1 and mode of these */2779 struct diff_filespec src_other, dst_other;2780 int try_merge;27812782 /*2783 * unpack_trees loads entries from common-commit2784 * into stage 1, from head-commit into stage 2, and2785 * from merge-commit into stage 3. We keep track2786 * of which side corresponds to the rename.2787 */2788 int renamed_stage = a_renames == renames1 ? 2 : 3;2789 int other_stage = a_renames == renames1 ? 3 : 2;27902791 /* BUG: We should only remove ren1_src in the base2792 * stage and in other_stage (think of rename +2793 * add-source case).2794 */2795 remove_file(o, 1, ren1_src,2796 renamed_stage == 2 || !was_tracked(o, ren1_src));27972798 oidcpy(&src_other.oid,2799 &ren1->src_entry->stages[other_stage].oid);2800 src_other.mode = ren1->src_entry->stages[other_stage].mode;2801 oidcpy(&dst_other.oid,2802 &ren1->dst_entry->stages[other_stage].oid);2803 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2804 try_merge = 0;28052806 if (oid_eq(&src_other.oid, &null_oid) &&2807 ren1->add_turned_into_rename) {2808 setup_rename_conflict_info(RENAME_VIA_DIR,2809 ren1->pair,2810 NULL,2811 branch1,2812 branch2,2813 ren1->dst_entry,2814 NULL,2815 o,2816 NULL,2817 NULL);2818 } else if (oid_eq(&src_other.oid, &null_oid)) {2819 setup_rename_conflict_info(RENAME_DELETE,2820 ren1->pair,2821 NULL,2822 branch1,2823 branch2,2824 ren1->dst_entry,2825 NULL,2826 o,2827 NULL,2828 NULL);2829 } else if ((dst_other.mode == ren1->pair->two->mode) &&2830 oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2831 /*2832 * Added file on the other side identical to2833 * the file being renamed: clean merge.2834 * Also, there is no need to overwrite the2835 * file already in the working copy, so call2836 * update_file_flags() instead of2837 * update_file().2838 */2839 if (update_file_flags(o,2840 &ren1->pair->two->oid,2841 ren1->pair->two->mode,2842 ren1_dst,2843 1, /* update_cache */2844 0 /* update_wd */))2845 clean_merge = -1;2846 } else if (!oid_eq(&dst_other.oid, &null_oid)) {2847 /*2848 * Probably not a clean merge, but it's2849 * premature to set clean_merge to 0 here,2850 * because if the rename merges cleanly and2851 * the merge exactly matches the newly added2852 * file, then the merge will be clean.2853 */2854 setup_rename_conflict_info(RENAME_ADD,2855 ren1->pair,2856 NULL,2857 branch1,2858 branch2,2859 ren1->dst_entry,2860 NULL,2861 o,2862 ren1->src_entry,2863 NULL);2864 } else2865 try_merge = 1;28662867 if (clean_merge < 0)2868 goto cleanup_and_return;2869 if (try_merge) {2870 struct diff_filespec *one, *a, *b;2871 src_other.path = (char *)ren1_src;28722873 one = ren1->pair->one;2874 if (a_renames == renames1) {2875 a = ren1->pair->two;2876 b = &src_other;2877 } else {2878 b = ren1->pair->two;2879 a = &src_other;2880 }2881 update_entry(ren1->dst_entry, one, a, b);2882 setup_rename_conflict_info(RENAME_NORMAL,2883 ren1->pair,2884 NULL,2885 branch1,2886 NULL,2887 ren1->dst_entry,2888 NULL,2889 o,2890 NULL,2891 NULL);2892 }2893 }2894 }2895cleanup_and_return:2896 string_list_clear(&a_by_dst, 0);2897 string_list_clear(&b_by_dst, 0);28982899 return clean_merge;2900}29012902struct rename_info {2903 struct string_list *head_renames;2904 struct string_list *merge_renames;2905};29062907static void initial_cleanup_rename(struct diff_queue_struct *pairs,2908 struct hashmap *dir_renames)2909{2910 struct hashmap_iter iter;2911 struct dir_rename_entry *e;29122913 hashmap_iter_init(dir_renames, &iter);2914 while ((e = hashmap_iter_next(&iter))) {2915 free(e->dir);2916 strbuf_release(&e->new_dir);2917 /* possible_new_dirs already cleared in get_directory_renames */2918 }2919 hashmap_free(dir_renames, 1);2920 free(dir_renames);29212922 free(pairs->queue);2923 free(pairs);2924}29252926static int detect_and_process_renames(struct merge_options *o,2927 struct tree *common,2928 struct tree *head,2929 struct tree *merge,2930 struct string_list *entries,2931 struct rename_info *ri)2932{2933 struct diff_queue_struct *head_pairs, *merge_pairs;2934 struct hashmap *dir_re_head, *dir_re_merge;2935 int clean = 1;29362937 ri->head_renames = NULL;2938 ri->merge_renames = NULL;29392940 if (!merge_detect_rename(o))2941 return 1;29422943 head_pairs = get_diffpairs(o, common, head);2944 merge_pairs = get_diffpairs(o, common, merge);29452946 if (o->detect_directory_renames) {2947 dir_re_head = get_directory_renames(head_pairs, head);2948 dir_re_merge = get_directory_renames(merge_pairs, merge);29492950 handle_directory_level_conflicts(o,2951 dir_re_head, head,2952 dir_re_merge, merge);2953 } else {2954 dir_re_head = xmalloc(sizeof(*dir_re_head));2955 dir_re_merge = xmalloc(sizeof(*dir_re_merge));2956 dir_rename_init(dir_re_head);2957 dir_rename_init(dir_re_merge);2958 }29592960 ri->head_renames = get_renames(o, head_pairs,2961 dir_re_merge, dir_re_head, head,2962 common, head, merge, entries,2963 &clean);2964 if (clean < 0)2965 goto cleanup;2966 ri->merge_renames = get_renames(o, merge_pairs,2967 dir_re_head, dir_re_merge, merge,2968 common, head, merge, entries,2969 &clean);2970 if (clean < 0)2971 goto cleanup;2972 clean &= process_renames(o, ri->head_renames, ri->merge_renames);29732974cleanup:2975 /*2976 * Some cleanup is deferred until cleanup_renames() because the2977 * data structures are still needed and referenced in2978 * process_entry(). But there are a few things we can free now.2979 */2980 initial_cleanup_rename(head_pairs, dir_re_head);2981 initial_cleanup_rename(merge_pairs, dir_re_merge);29822983 return clean;2984}29852986static void final_cleanup_rename(struct string_list *rename)2987{2988 const struct rename *re;2989 int i;29902991 if (rename == NULL)2992 return;29932994 for (i = 0; i < rename->nr; i++) {2995 re = rename->items[i].util;2996 diff_free_filepair(re->pair);2997 }2998 string_list_clear(rename, 1);2999 free(rename);3000}30013002static void final_cleanup_renames(struct rename_info *re_info)3003{3004 final_cleanup_rename(re_info->head_renames);3005 final_cleanup_rename(re_info->merge_renames);3006}30073008static struct object_id *stage_oid(const struct object_id *oid, unsigned mode)3009{3010 return (is_null_oid(oid) || mode == 0) ? NULL: (struct object_id *)oid;3011}30123013static int read_oid_strbuf(struct merge_options *o,3014 const struct object_id *oid,3015 struct strbuf *dst)3016{3017 void *buf;3018 enum object_type type;3019 unsigned long size;3020 buf = read_object_file(oid, &type, &size);3021 if (!buf)3022 return err(o, _("cannot read object %s"), oid_to_hex(oid));3023 if (type != OBJ_BLOB) {3024 free(buf);3025 return err(o, _("object %s is not a blob"), oid_to_hex(oid));3026 }3027 strbuf_attach(dst, buf, size, size + 1);3028 return 0;3029}30303031static int blob_unchanged(struct merge_options *opt,3032 const struct object_id *o_oid,3033 unsigned o_mode,3034 const struct object_id *a_oid,3035 unsigned a_mode,3036 int renormalize, const char *path)3037{3038 struct strbuf o = STRBUF_INIT;3039 struct strbuf a = STRBUF_INIT;3040 int ret = 0; /* assume changed for safety */30413042 if (a_mode != o_mode)3043 return 0;3044 if (oid_eq(o_oid, a_oid))3045 return 1;3046 if (!renormalize)3047 return 0;30483049 assert(o_oid && a_oid);3050 if (read_oid_strbuf(opt, o_oid, &o) || read_oid_strbuf(opt, a_oid, &a))3051 goto error_return;3052 /*3053 * Note: binary | is used so that both renormalizations are3054 * performed. Comparison can be skipped if both files are3055 * unchanged since their sha1s have already been compared.3056 */3057 if (renormalize_buffer(opt->repo->index, path, o.buf, o.len, &o) |3058 renormalize_buffer(opt->repo->index, path, a.buf, a.len, &a))3059 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));30603061error_return:3062 strbuf_release(&o);3063 strbuf_release(&a);3064 return ret;3065}30663067static int handle_modify_delete(struct merge_options *o,3068 const char *path,3069 struct object_id *o_oid, int o_mode,3070 struct object_id *a_oid, int a_mode,3071 struct object_id *b_oid, int b_mode)3072{3073 const char *modify_branch, *delete_branch;3074 struct object_id *changed_oid;3075 int changed_mode;30763077 if (a_oid) {3078 modify_branch = o->branch1;3079 delete_branch = o->branch2;3080 changed_oid = a_oid;3081 changed_mode = a_mode;3082 } else {3083 modify_branch = o->branch2;3084 delete_branch = o->branch1;3085 changed_oid = b_oid;3086 changed_mode = b_mode;3087 }30883089 return handle_change_delete(o,3090 path, NULL,3091 o_oid, o_mode,3092 changed_oid, changed_mode,3093 modify_branch, delete_branch,3094 _("modify"), _("modified"));3095}30963097static int handle_content_merge(struct merge_options *o,3098 const char *path,3099 int is_dirty,3100 struct object_id *o_oid, int o_mode,3101 struct object_id *a_oid, int a_mode,3102 struct object_id *b_oid, int b_mode,3103 struct rename_conflict_info *rename_conflict_info)3104{3105 const char *reason = _("content");3106 const char *path1 = NULL, *path2 = NULL;3107 struct merge_file_info mfi;3108 struct diff_filespec one, a, b;3109 unsigned df_conflict_remains = 0;31103111 if (!o_oid) {3112 reason = _("add/add");3113 o_oid = (struct object_id *)&null_oid;3114 }3115 one.path = a.path = b.path = (char *)path;3116 oidcpy(&one.oid, o_oid);3117 one.mode = o_mode;3118 oidcpy(&a.oid, a_oid);3119 a.mode = a_mode;3120 oidcpy(&b.oid, b_oid);3121 b.mode = b_mode;31223123 if (rename_conflict_info) {3124 struct diff_filepair *pair1 = rename_conflict_info->pair1;31253126 path1 = (o->branch1 == rename_conflict_info->branch1) ?3127 pair1->two->path : pair1->one->path;3128 /* If rename_conflict_info->pair2 != NULL, we are in3129 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a3130 * normal rename.3131 */3132 path2 = (rename_conflict_info->pair2 ||3133 o->branch2 == rename_conflict_info->branch1) ?3134 pair1->two->path : pair1->one->path;3135 one.path = pair1->one->path;3136 a.path = (char *)path1;3137 b.path = (char *)path2;31383139 if (dir_in_way(o->repo->index, path, !o->call_depth,3140 S_ISGITLINK(pair1->two->mode)))3141 df_conflict_remains = 1;3142 }3143 if (merge_mode_and_contents(o, &one, &a, &b, path,3144 o->branch1, o->branch2,3145 o->call_depth * 2, &mfi))3146 return -1;31473148 /*3149 * We can skip updating the working tree file iff:3150 * a) The merge is clean3151 * b) The merge matches what was in HEAD (content, mode, pathname)3152 * c) The target path is usable (i.e. not involved in D/F conflict)3153 */3154 if (mfi.clean &&3155 was_tracked_and_matches(o, path, &mfi.oid, mfi.mode) &&3156 !df_conflict_remains) {3157 int pos;3158 struct cache_entry *ce;31593160 output(o, 3, _("Skipped %s (merged same as existing)"), path);3161 if (add_cacheinfo(o, mfi.mode, &mfi.oid, path,3162 0, (!o->call_depth && !is_dirty), 0))3163 return -1;3164 /*3165 * However, add_cacheinfo() will delete the old cache entry3166 * and add a new one. We need to copy over any skip_worktree3167 * flag to avoid making the file appear as if it were3168 * deleted by the user.3169 */3170 pos = index_name_pos(&o->orig_index, path, strlen(path));3171 ce = o->orig_index.cache[pos];3172 if (ce_skip_worktree(ce)) {3173 pos = index_name_pos(o->repo->index, path, strlen(path));3174 ce = o->repo->index->cache[pos];3175 ce->ce_flags |= CE_SKIP_WORKTREE;3176 }3177 return mfi.clean;3178 }31793180 if (!mfi.clean) {3181 if (S_ISGITLINK(mfi.mode))3182 reason = _("submodule");3183 output(o, 1, _("CONFLICT (%s): Merge conflict in %s"),3184 reason, path);3185 if (rename_conflict_info && !df_conflict_remains)3186 if (update_stages(o, path, &one, &a, &b))3187 return -1;3188 }31893190 if (df_conflict_remains || is_dirty) {3191 char *new_path;3192 if (o->call_depth) {3193 remove_file_from_index(o->repo->index, path);3194 } else {3195 if (!mfi.clean) {3196 if (update_stages(o, path, &one, &a, &b))3197 return -1;3198 } else {3199 int file_from_stage2 = was_tracked(o, path);3200 struct diff_filespec merged;3201 oidcpy(&merged.oid, &mfi.oid);3202 merged.mode = mfi.mode;32033204 if (update_stages(o, path, NULL,3205 file_from_stage2 ? &merged : NULL,3206 file_from_stage2 ? NULL : &merged))3207 return -1;3208 }32093210 }3211 new_path = unique_path(o, path, rename_conflict_info->branch1);3212 if (is_dirty) {3213 output(o, 1, _("Refusing to lose dirty file at %s"),3214 path);3215 }3216 output(o, 1, _("Adding as %s instead"), new_path);3217 if (update_file(o, 0, &mfi.oid, mfi.mode, new_path)) {3218 free(new_path);3219 return -1;3220 }3221 free(new_path);3222 mfi.clean = 0;3223 } else if (update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))3224 return -1;3225 return !is_dirty && mfi.clean;3226}32273228static int handle_rename_normal(struct merge_options *o,3229 const char *path,3230 struct object_id *o_oid, unsigned int o_mode,3231 struct object_id *a_oid, unsigned int a_mode,3232 struct object_id *b_oid, unsigned int b_mode,3233 struct rename_conflict_info *ci)3234{3235 /* Merge the content and write it out */3236 return handle_content_merge(o, path, was_dirty(o, path),3237 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3238 ci);3239}32403241/* Per entry merge function */3242static int process_entry(struct merge_options *o,3243 const char *path, struct stage_data *entry)3244{3245 int clean_merge = 1;3246 int normalize = o->renormalize;3247 unsigned o_mode = entry->stages[1].mode;3248 unsigned a_mode = entry->stages[2].mode;3249 unsigned b_mode = entry->stages[3].mode;3250 struct object_id *o_oid = stage_oid(&entry->stages[1].oid, o_mode);3251 struct object_id *a_oid = stage_oid(&entry->stages[2].oid, a_mode);3252 struct object_id *b_oid = stage_oid(&entry->stages[3].oid, b_mode);32533254 entry->processed = 1;3255 if (entry->rename_conflict_info) {3256 struct rename_conflict_info *conflict_info = entry->rename_conflict_info;3257 switch (conflict_info->rename_type) {3258 case RENAME_NORMAL:3259 case RENAME_ONE_FILE_TO_ONE:3260 clean_merge = handle_rename_normal(o,3261 path,3262 o_oid, o_mode,3263 a_oid, a_mode,3264 b_oid, b_mode,3265 conflict_info);3266 break;3267 case RENAME_VIA_DIR:3268 clean_merge = 1;3269 if (handle_rename_via_dir(o,3270 conflict_info->pair1,3271 conflict_info->branch1,3272 conflict_info->branch2))3273 clean_merge = -1;3274 break;3275 case RENAME_ADD:3276 /*3277 * Probably unclean merge, but if the renamed file3278 * merges cleanly and the result can then be3279 * two-way merged cleanly with the added file, I3280 * guess it's a clean merge?3281 */3282 clean_merge = handle_rename_add(o, conflict_info);3283 break;3284 case RENAME_DELETE:3285 clean_merge = 0;3286 if (handle_rename_delete(o,3287 conflict_info->pair1,3288 conflict_info->branch1,3289 conflict_info->branch2))3290 clean_merge = -1;3291 break;3292 case RENAME_ONE_FILE_TO_TWO:3293 clean_merge = 0;3294 if (handle_rename_rename_1to2(o, conflict_info))3295 clean_merge = -1;3296 break;3297 case RENAME_TWO_FILES_TO_ONE:3298 /*3299 * Probably unclean merge, but if the two renamed3300 * files merge cleanly and the two resulting files3301 * can then be two-way merged cleanly, I guess it's3302 * a clean merge?3303 */3304 clean_merge = handle_rename_rename_2to1(o,3305 conflict_info);3306 break;3307 default:3308 entry->processed = 0;3309 break;3310 }3311 } else if (o_oid && (!a_oid || !b_oid)) {3312 /* Case A: Deleted in one */3313 if ((!a_oid && !b_oid) ||3314 (!b_oid && blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||3315 (!a_oid && blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {3316 /* Deleted in both or deleted in one and3317 * unchanged in the other */3318 if (a_oid)3319 output(o, 2, _("Removing %s"), path);3320 /* do not touch working file if it did not exist */3321 remove_file(o, 1, path, !a_oid);3322 } else {3323 /* Modify/delete; deleted side may have put a directory in the way */3324 clean_merge = 0;3325 if (handle_modify_delete(o, path, o_oid, o_mode,3326 a_oid, a_mode, b_oid, b_mode))3327 clean_merge = -1;3328 }3329 } else if ((!o_oid && a_oid && !b_oid) ||3330 (!o_oid && !a_oid && b_oid)) {3331 /* Case B: Added in one. */3332 /* [nothing|directory] -> ([nothing|directory], file) */33333334 const char *add_branch;3335 const char *other_branch;3336 unsigned mode;3337 const struct object_id *oid;3338 const char *conf;33393340 if (a_oid) {3341 add_branch = o->branch1;3342 other_branch = o->branch2;3343 mode = a_mode;3344 oid = a_oid;3345 conf = _("file/directory");3346 } else {3347 add_branch = o->branch2;3348 other_branch = o->branch1;3349 mode = b_mode;3350 oid = b_oid;3351 conf = _("directory/file");3352 }3353 if (dir_in_way(o->repo->index, path,3354 !o->call_depth && !S_ISGITLINK(a_mode),3355 0)) {3356 char *new_path = unique_path(o, path, add_branch);3357 clean_merge = 0;3358 output(o, 1, _("CONFLICT (%s): There is a directory with name %s in %s. "3359 "Adding %s as %s"),3360 conf, path, other_branch, path, new_path);3361 if (update_file(o, 0, oid, mode, new_path))3362 clean_merge = -1;3363 else if (o->call_depth)3364 remove_file_from_index(o->repo->index, path);3365 free(new_path);3366 } else {3367 output(o, 2, _("Adding %s"), path);3368 /* do not overwrite file if already present */3369 if (update_file_flags(o, oid, mode, path, 1, !a_oid))3370 clean_merge = -1;3371 }3372 } else if (a_oid && b_oid) {3373 if (!o_oid) {3374 /* Case C: Added in both (check for same permissions) */3375 output(o, 1,3376 _("CONFLICT (add/add): Merge conflict in %s"),3377 path);3378 clean_merge = handle_file_collision(o,3379 path, NULL, NULL,3380 o->branch1,3381 o->branch2,3382 a_oid, a_mode,3383 b_oid, b_mode);3384 } else {3385 /* case D: Modified in both, but differently. */3386 int is_dirty = 0; /* unpack_trees would have bailed if dirty */3387 clean_merge = handle_content_merge(o, path,3388 is_dirty,3389 o_oid, o_mode,3390 a_oid, a_mode,3391 b_oid, b_mode,3392 NULL);3393 }3394 } else if (!o_oid && !a_oid && !b_oid) {3395 /*3396 * this entry was deleted altogether. a_mode == 0 means3397 * we had that path and want to actively remove it.3398 */3399 remove_file(o, 1, path, !a_mode);3400 } else3401 BUG("fatal merge failure, shouldn't happen.");34023403 return clean_merge;3404}34053406int merge_trees(struct merge_options *o,3407 struct tree *head,3408 struct tree *merge,3409 struct tree *common,3410 struct tree **result)3411{3412 struct index_state *istate = o->repo->index;3413 int code, clean;3414 struct strbuf sb = STRBUF_INIT;34153416 if (!o->call_depth && repo_index_has_changes(o->repo, head, &sb)) {3417 err(o, _("Your local changes to the following files would be overwritten by merge:\n %s"),3418 sb.buf);3419 return -1;3420 }34213422 if (o->subtree_shift) {3423 merge = shift_tree_object(o->repo, head, merge, o->subtree_shift);3424 common = shift_tree_object(o->repo, head, common, o->subtree_shift);3425 }34263427 if (oid_eq(&common->object.oid, &merge->object.oid)) {3428 output(o, 0, _("Already up to date!"));3429 *result = head;3430 return 1;3431 }34323433 code = unpack_trees_start(o, common, head, merge);34343435 if (code != 0) {3436 if (show(o, 4) || o->call_depth)3437 err(o, _("merging of trees %s and %s failed"),3438 oid_to_hex(&head->object.oid),3439 oid_to_hex(&merge->object.oid));3440 unpack_trees_finish(o);3441 return -1;3442 }34433444 if (unmerged_index(istate)) {3445 struct string_list *entries;3446 struct rename_info re_info;3447 int i;3448 /*3449 * Only need the hashmap while processing entries, so3450 * initialize it here and free it when we are done running3451 * through the entries. Keeping it in the merge_options as3452 * opposed to decaring a local hashmap is for convenience3453 * so that we don't have to pass it to around.3454 */3455 hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL, 512);3456 get_files_dirs(o, head);3457 get_files_dirs(o, merge);34583459 entries = get_unmerged(o->repo->index);3460 clean = detect_and_process_renames(o, common, head, merge,3461 entries, &re_info);3462 record_df_conflict_files(o, entries);3463 if (clean < 0)3464 goto cleanup;3465 for (i = entries->nr-1; 0 <= i; i--) {3466 const char *path = entries->items[i].string;3467 struct stage_data *e = entries->items[i].util;3468 if (!e->processed) {3469 int ret = process_entry(o, path, e);3470 if (!ret)3471 clean = 0;3472 else if (ret < 0) {3473 clean = ret;3474 goto cleanup;3475 }3476 }3477 }3478 for (i = 0; i < entries->nr; i++) {3479 struct stage_data *e = entries->items[i].util;3480 if (!e->processed)3481 BUG("unprocessed path??? %s",3482 entries->items[i].string);3483 }34843485 cleanup:3486 final_cleanup_renames(&re_info);34873488 string_list_clear(entries, 1);3489 free(entries);34903491 hashmap_free(&o->current_file_dir_set, 1);34923493 if (clean < 0) {3494 unpack_trees_finish(o);3495 return clean;3496 }3497 }3498 else3499 clean = 1;35003501 unpack_trees_finish(o);35023503 if (o->call_depth && !(*result = write_tree_from_memory(o)))3504 return -1;35053506 return clean;3507}35083509static struct commit_list *reverse_commit_list(struct commit_list *list)3510{3511 struct commit_list *next = NULL, *current, *backup;3512 for (current = list; current; current = backup) {3513 backup = current->next;3514 current->next = next;3515 next = current;3516 }3517 return next;3518}35193520/*3521 * Merge the commits h1 and h2, return the resulting virtual3522 * commit object and a flag indicating the cleanness of the merge.3523 */3524int merge_recursive(struct merge_options *o,3525 struct commit *h1,3526 struct commit *h2,3527 struct commit_list *ca,3528 struct commit **result)3529{3530 struct commit_list *iter;3531 struct commit *merged_common_ancestors;3532 struct tree *mrtree;3533 int clean;35343535 if (show(o, 4)) {3536 output(o, 4, _("Merging:"));3537 output_commit_title(o, h1);3538 output_commit_title(o, h2);3539 }35403541 if (!ca) {3542 ca = get_merge_bases(h1, h2);3543 ca = reverse_commit_list(ca);3544 }35453546 if (show(o, 5)) {3547 unsigned cnt = commit_list_count(ca);35483549 output(o, 5, Q_("found %u common ancestor:",3550 "found %u common ancestors:", cnt), cnt);3551 for (iter = ca; iter; iter = iter->next)3552 output_commit_title(o, iter->item);3553 }35543555 merged_common_ancestors = pop_commit(&ca);3556 if (merged_common_ancestors == NULL) {3557 /* if there is no common ancestor, use an empty tree */3558 struct tree *tree;35593560 tree = lookup_tree(o->repo, o->repo->hash_algo->empty_tree);3561 merged_common_ancestors = make_virtual_commit(o->repo, tree, "ancestor");3562 }35633564 for (iter = ca; iter; iter = iter->next) {3565 const char *saved_b1, *saved_b2;3566 o->call_depth++;3567 /*3568 * When the merge fails, the result contains files3569 * with conflict markers. The cleanness flag is3570 * ignored (unless indicating an error), it was never3571 * actually used, as result of merge_trees has always3572 * overwritten it: the committed "conflicts" were3573 * already resolved.3574 */3575 discard_index(o->repo->index);3576 saved_b1 = o->branch1;3577 saved_b2 = o->branch2;3578 o->branch1 = "Temporary merge branch 1";3579 o->branch2 = "Temporary merge branch 2";3580 if (merge_recursive(o, merged_common_ancestors, iter->item,3581 NULL, &merged_common_ancestors) < 0)3582 return -1;3583 o->branch1 = saved_b1;3584 o->branch2 = saved_b2;3585 o->call_depth--;35863587 if (!merged_common_ancestors)3588 return err(o, _("merge returned no commit"));3589 }35903591 discard_index(o->repo->index);3592 if (!o->call_depth)3593 repo_read_index(o->repo);35943595 o->ancestor = "merged common ancestors";3596 clean = merge_trees(o, get_commit_tree(h1), get_commit_tree(h2),3597 get_commit_tree(merged_common_ancestors),3598 &mrtree);3599 if (clean < 0) {3600 flush_output(o);3601 return clean;3602 }36033604 if (o->call_depth) {3605 *result = make_virtual_commit(o->repo, mrtree, "merged tree");3606 commit_list_insert(h1, &(*result)->parents);3607 commit_list_insert(h2, &(*result)->parents->next);3608 }3609 flush_output(o);3610 if (!o->call_depth && o->buffer_output < 2)3611 strbuf_release(&o->obuf);3612 if (show(o, 2))3613 diff_warn_rename_limit("merge.renamelimit",3614 o->needed_rename_limit, 0);3615 return clean;3616}36173618static struct commit *get_ref(struct repository *repo, const struct object_id *oid,3619 const char *name)3620{3621 struct object *object;36223623 object = deref_tag(repo, parse_object(repo, oid),3624 name, strlen(name));3625 if (!object)3626 return NULL;3627 if (object->type == OBJ_TREE)3628 return make_virtual_commit(repo, (struct tree*)object, name);3629 if (object->type != OBJ_COMMIT)3630 return NULL;3631 if (parse_commit((struct commit *)object))3632 return NULL;3633 return (struct commit *)object;3634}36353636int merge_recursive_generic(struct merge_options *o,3637 const struct object_id *head,3638 const struct object_id *merge,3639 int num_base_list,3640 const struct object_id **base_list,3641 struct commit **result)3642{3643 int clean;3644 struct lock_file lock = LOCK_INIT;3645 struct commit *head_commit = get_ref(o->repo, head, o->branch1);3646 struct commit *next_commit = get_ref(o->repo, merge, o->branch2);3647 struct commit_list *ca = NULL;36483649 if (base_list) {3650 int i;3651 for (i = 0; i < num_base_list; ++i) {3652 struct commit *base;3653 if (!(base = get_ref(o->repo, base_list[i], oid_to_hex(base_list[i]))))3654 return err(o, _("Could not parse object '%s'"),3655 oid_to_hex(base_list[i]));3656 commit_list_insert(base, &ca);3657 }3658 }36593660 repo_hold_locked_index(o->repo, &lock, LOCK_DIE_ON_ERROR);3661 clean = merge_recursive(o, head_commit, next_commit, ca,3662 result);3663 if (clean < 0) {3664 rollback_lock_file(&lock);3665 return clean;3666 }36673668 if (write_locked_index(o->repo->index, &lock,3669 COMMIT_LOCK | SKIP_IF_UNCHANGED))3670 return err(o, _("Unable to write index."));36713672 return clean ? 0 : 1;3673}36743675static void merge_recursive_config(struct merge_options *o)3676{3677 char *value = NULL;3678 git_config_get_int("merge.verbosity", &o->verbosity);3679 git_config_get_int("diff.renamelimit", &o->diff_rename_limit);3680 git_config_get_int("merge.renamelimit", &o->merge_rename_limit);3681 if (!git_config_get_string("diff.renames", &value)) {3682 o->diff_detect_rename = git_config_rename("diff.renames", value);3683 free(value);3684 }3685 if (!git_config_get_string("merge.renames", &value)) {3686 o->merge_detect_rename = git_config_rename("merge.renames", value);3687 free(value);3688 }3689 git_config(git_xmerge_config, NULL);3690}36913692void init_merge_options(struct merge_options *o,3693 struct repository *repo)3694{3695 const char *merge_verbosity;3696 memset(o, 0, sizeof(struct merge_options));3697 o->repo = repo;3698 o->verbosity = 2;3699 o->buffer_output = 1;3700 o->diff_rename_limit = -1;3701 o->merge_rename_limit = -1;3702 o->renormalize = 0;3703 o->diff_detect_rename = -1;3704 o->merge_detect_rename = -1;3705 o->detect_directory_renames = 1;3706 merge_recursive_config(o);3707 merge_verbosity = getenv("GIT_MERGE_VERBOSITY");3708 if (merge_verbosity)3709 o->verbosity = strtol(merge_verbosity, NULL, 10);3710 if (o->verbosity >= 5)3711 o->buffer_output = 0;3712 strbuf_init(&o->obuf, 0);3713 string_list_init(&o->df_conflict_file_set, 1);3714}37153716int parse_merge_opt(struct merge_options *o, const char *s)3717{3718 const char *arg;37193720 if (!s || !*s)3721 return -1;3722 if (!strcmp(s, "ours"))3723 o->recursive_variant = MERGE_RECURSIVE_OURS;3724 else if (!strcmp(s, "theirs"))3725 o->recursive_variant = MERGE_RECURSIVE_THEIRS;3726 else if (!strcmp(s, "subtree"))3727 o->subtree_shift = "";3728 else if (skip_prefix(s, "subtree=", &arg))3729 o->subtree_shift = arg;3730 else if (!strcmp(s, "patience"))3731 o->xdl_opts = DIFF_WITH_ALG(o, PATIENCE_DIFF);3732 else if (!strcmp(s, "histogram"))3733 o->xdl_opts = DIFF_WITH_ALG(o, HISTOGRAM_DIFF);3734 else if (skip_prefix(s, "diff-algorithm=", &arg)) {3735 long value = parse_algorithm_value(arg);3736 if (value < 0)3737 return -1;3738 /* clear out previous settings */3739 DIFF_XDL_CLR(o, NEED_MINIMAL);3740 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3741 o->xdl_opts |= value;3742 }3743 else if (!strcmp(s, "ignore-space-change"))3744 DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);3745 else if (!strcmp(s, "ignore-all-space"))3746 DIFF_XDL_SET(o, IGNORE_WHITESPACE);3747 else if (!strcmp(s, "ignore-space-at-eol"))3748 DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);3749 else if (!strcmp(s, "ignore-cr-at-eol"))3750 DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);3751 else if (!strcmp(s, "renormalize"))3752 o->renormalize = 1;3753 else if (!strcmp(s, "no-renormalize"))3754 o->renormalize = 0;3755 else if (!strcmp(s, "no-renames"))3756 o->merge_detect_rename = 0;3757 else if (!strcmp(s, "find-renames")) {3758 o->merge_detect_rename = 1;3759 o->rename_score = 0;3760 }3761 else if (skip_prefix(s, "find-renames=", &arg) ||3762 skip_prefix(s, "rename-threshold=", &arg)) {3763 if ((o->rename_score = parse_rename_score(&arg)) == -1 || *arg != 0)3764 return -1;3765 o->merge_detect_rename = 1;3766 }3767 else3768 return -1;3769 return 0;3770}