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 tree *one, struct tree *two, 150 const char *subtree_shift) 151{ 152 struct object_id shifted; 153 154 if (!*subtree_shift) { 155 shift_tree(&one->object.oid, &two->object.oid, &shifted, 0); 156 } else { 157 shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 158 subtree_shift); 159 } 160 if (oideq(&two->object.oid, &shifted)) 161 return two; 162 return lookup_tree(the_repository, &shifted); 163} 164 165static struct commit *make_virtual_commit(struct tree *tree, const char *comment) 166{ 167 struct commit *commit = alloc_commit_node(the_repository); 168 169 set_merge_remote_desc(commit, comment, (struct object *)commit); 170 commit->maybe_tree = tree; 171 commit->object.parsed = 1; 172 return commit; 173} 174 175/* 176 * Since we use get_tree_entry(), which does not put the read object into 177 * the object pool, we cannot rely on a == b. 178 */ 179static int oid_eq(const struct object_id *a, const struct object_id *b) 180{ 181 if (!a && !b) 182 return 2; 183 return a && b && oideq(a, b); 184} 185 186enum rename_type { 187 RENAME_NORMAL = 0, 188 RENAME_VIA_DIR, 189 RENAME_ADD, 190 RENAME_DELETE, 191 RENAME_ONE_FILE_TO_ONE, 192 RENAME_ONE_FILE_TO_TWO, 193 RENAME_TWO_FILES_TO_ONE 194}; 195 196struct rename_conflict_info { 197 enum rename_type rename_type; 198 struct diff_filepair *pair1; 199 struct diff_filepair *pair2; 200 const char *branch1; 201 const char *branch2; 202 struct stage_data *dst_entry1; 203 struct stage_data *dst_entry2; 204 struct diff_filespec ren1_other; 205 struct diff_filespec ren2_other; 206}; 207 208/* 209 * Since we want to write the index eventually, we cannot reuse the index 210 * for these (temporary) data. 211 */ 212struct stage_data { 213 struct { 214 unsigned mode; 215 struct object_id oid; 216 } stages[4]; 217 struct rename_conflict_info *rename_conflict_info; 218 unsigned processed:1; 219}; 220 221static inline void setup_rename_conflict_info(enum rename_type rename_type, 222 struct diff_filepair *pair1, 223 struct diff_filepair *pair2, 224 const char *branch1, 225 const char *branch2, 226 struct stage_data *dst_entry1, 227 struct stage_data *dst_entry2, 228 struct merge_options *o, 229 struct stage_data *src_entry1, 230 struct stage_data *src_entry2) 231{ 232 int ostage1 = 0, ostage2; 233 struct rename_conflict_info *ci; 234 235 /* 236 * When we have two renames involved, it's easiest to get the 237 * correct things into stage 2 and 3, and to make sure that the 238 * content merge puts HEAD before the other branch if we just 239 * ensure that branch1 == o->branch1. So, simply flip arguments 240 * around if we don't have that. 241 */ 242 if (dst_entry2 && branch1 != o->branch1) { 243 setup_rename_conflict_info(rename_type, 244 pair2, pair1, 245 branch2, branch1, 246 dst_entry2, dst_entry1, 247 o, 248 src_entry2, src_entry1); 249 return; 250 } 251 252 ci = xcalloc(1, sizeof(struct rename_conflict_info)); 253 ci->rename_type = rename_type; 254 ci->pair1 = pair1; 255 ci->branch1 = branch1; 256 ci->branch2 = branch2; 257 258 ci->dst_entry1 = dst_entry1; 259 dst_entry1->rename_conflict_info = ci; 260 dst_entry1->processed = 0; 261 262 assert(!pair2 == !dst_entry2); 263 if (dst_entry2) { 264 ci->dst_entry2 = dst_entry2; 265 ci->pair2 = pair2; 266 dst_entry2->rename_conflict_info = ci; 267 } 268 269 /* 270 * For each rename, there could have been 271 * modifications on the side of history where that 272 * file was not renamed. 273 */ 274 if (rename_type == RENAME_ADD || 275 rename_type == RENAME_TWO_FILES_TO_ONE) { 276 ostage1 = o->branch1 == branch1 ? 3 : 2; 277 278 ci->ren1_other.path = pair1->one->path; 279 oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid); 280 ci->ren1_other.mode = src_entry1->stages[ostage1].mode; 281 } 282 283 if (rename_type == RENAME_TWO_FILES_TO_ONE) { 284 ostage2 = ostage1 ^ 1; 285 286 ci->ren2_other.path = pair2->one->path; 287 oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid); 288 ci->ren2_other.mode = src_entry2->stages[ostage2].mode; 289 } 290} 291 292static int show(struct merge_options *o, int v) 293{ 294 return (!o->call_depth && o->verbosity >= v) || o->verbosity >= 5; 295} 296 297__attribute__((format (printf, 3, 4))) 298static void output(struct merge_options *o, int v, const char *fmt, ...) 299{ 300 va_list ap; 301 302 if (!show(o, v)) 303 return; 304 305 strbuf_addchars(&o->obuf, ' ', o->call_depth * 2); 306 307 va_start(ap, fmt); 308 strbuf_vaddf(&o->obuf, fmt, ap); 309 va_end(ap); 310 311 strbuf_addch(&o->obuf, '\n'); 312 if (!o->buffer_output) 313 flush_output(o); 314} 315 316static void output_commit_title(struct merge_options *o, struct commit *commit) 317{ 318 struct merge_remote_desc *desc; 319 320 strbuf_addchars(&o->obuf, ' ', o->call_depth * 2); 321 desc = merge_remote_util(commit); 322 if (desc) 323 strbuf_addf(&o->obuf, "virtual %s\n", desc->name); 324 else { 325 strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid, 326 DEFAULT_ABBREV); 327 strbuf_addch(&o->obuf, ' '); 328 if (parse_commit(commit) != 0) 329 strbuf_addstr(&o->obuf, _("(bad commit)\n")); 330 else { 331 const char *title; 332 const char *msg = get_commit_buffer(commit, NULL); 333 int len = find_commit_subject(msg, &title); 334 if (len) 335 strbuf_addf(&o->obuf, "%.*s\n", len, title); 336 unuse_commit_buffer(commit, msg); 337 } 338 } 339 flush_output(o); 340} 341 342static int add_cacheinfo(struct merge_options *o, 343 unsigned int mode, const struct object_id *oid, 344 const char *path, int stage, int refresh, int options) 345{ 346 struct index_state *istate = o->repo->index; 347 struct cache_entry *ce; 348 int ret; 349 350 ce = make_cache_entry(istate, mode, oid ? oid : &null_oid, path, stage, 0); 351 if (!ce) 352 return err(o, _("add_cacheinfo failed for path '%s'; merge aborting."), path); 353 354 ret = add_index_entry(istate, ce, options); 355 if (refresh) { 356 struct cache_entry *nce; 357 358 nce = refresh_cache_entry(istate, ce, 359 CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 360 if (!nce) 361 return err(o, _("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); 362 if (nce != ce) 363 ret = add_index_entry(istate, nce, options); 364 } 365 return ret; 366} 367 368static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree) 369{ 370 parse_tree(tree); 371 init_tree_desc(desc, tree->buffer, tree->size); 372} 373 374static int unpack_trees_start(struct merge_options *o, 375 struct tree *common, 376 struct tree *head, 377 struct tree *merge) 378{ 379 int rc; 380 struct tree_desc t[3]; 381 struct index_state tmp_index = { NULL }; 382 383 memset(&o->unpack_opts, 0, sizeof(o->unpack_opts)); 384 if (o->call_depth) 385 o->unpack_opts.index_only = 1; 386 else 387 o->unpack_opts.update = 1; 388 o->unpack_opts.merge = 1; 389 o->unpack_opts.head_idx = 2; 390 o->unpack_opts.fn = threeway_merge; 391 o->unpack_opts.src_index = o->repo->index; 392 o->unpack_opts.dst_index = &tmp_index; 393 o->unpack_opts.aggressive = !merge_detect_rename(o); 394 setup_unpack_trees_porcelain(&o->unpack_opts, "merge"); 395 396 init_tree_desc_from_tree(t+0, common); 397 init_tree_desc_from_tree(t+1, head); 398 init_tree_desc_from_tree(t+2, merge); 399 400 rc = unpack_trees(3, t, &o->unpack_opts); 401 cache_tree_free(&o->repo->index->cache_tree); 402 403 /* 404 * Update o->repo->index to match the new results, AFTER saving a copy 405 * in o->orig_index. Update src_index to point to the saved copy. 406 * (verify_uptodate() checks src_index, and the original index is 407 * the one that had the necessary modification timestamps.) 408 */ 409 o->orig_index = *o->repo->index; 410 *o->repo->index = tmp_index; 411 o->unpack_opts.src_index = &o->orig_index; 412 413 return rc; 414} 415 416static void unpack_trees_finish(struct merge_options *o) 417{ 418 discard_index(&o->orig_index); 419 clear_unpack_trees_porcelain(&o->unpack_opts); 420} 421 422struct tree *write_tree_from_memory(struct merge_options *o) 423{ 424 struct tree *result = NULL; 425 struct index_state *istate = o->repo->index; 426 427 if (unmerged_index(istate)) { 428 int i; 429 fprintf(stderr, "BUG: There are unmerged index entries:\n"); 430 for (i = 0; i < istate->cache_nr; i++) { 431 const struct cache_entry *ce = istate->cache[i]; 432 if (ce_stage(ce)) 433 fprintf(stderr, "BUG: %d %.*s\n", ce_stage(ce), 434 (int)ce_namelen(ce), ce->name); 435 } 436 BUG("unmerged index entries in merge-recursive.c"); 437 } 438 439 if (!istate->cache_tree) 440 istate->cache_tree = cache_tree(); 441 442 if (!cache_tree_fully_valid(istate->cache_tree) && 443 cache_tree_update(istate, 0) < 0) { 444 err(o, _("error building trees")); 445 return NULL; 446 } 447 448 result = lookup_tree(the_repository, &istate->cache_tree->oid); 449 450 return result; 451} 452 453static int save_files_dirs(const struct object_id *oid, 454 struct strbuf *base, const char *path, 455 unsigned int mode, int stage, void *context) 456{ 457 struct path_hashmap_entry *entry; 458 int baselen = base->len; 459 struct merge_options *o = context; 460 461 strbuf_addstr(base, path); 462 463 FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 464 hashmap_entry_init(entry, path_hash(entry->path)); 465 hashmap_add(&o->current_file_dir_set, entry); 466 467 strbuf_setlen(base, baselen); 468 return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0); 469} 470 471static void get_files_dirs(struct merge_options *o, struct tree *tree) 472{ 473 struct pathspec match_all; 474 memset(&match_all, 0, sizeof(match_all)); 475 read_tree_recursive(tree, "", 0, 0, &match_all, save_files_dirs, o); 476} 477 478static int get_tree_entry_if_blob(const struct object_id *tree, 479 const char *path, 480 struct object_id *hashy, 481 unsigned int *mode_o) 482{ 483 int ret; 484 485 ret = get_tree_entry(tree, path, hashy, mode_o); 486 if (S_ISDIR(*mode_o)) { 487 oidcpy(hashy, &null_oid); 488 *mode_o = 0; 489 } 490 return ret; 491} 492 493/* 494 * Returns an index_entry instance which doesn't have to correspond to 495 * a real cache entry in Git's index. 496 */ 497static struct stage_data *insert_stage_data(const char *path, 498 struct tree *o, struct tree *a, struct tree *b, 499 struct string_list *entries) 500{ 501 struct string_list_item *item; 502 struct stage_data *e = xcalloc(1, sizeof(struct stage_data)); 503 get_tree_entry_if_blob(&o->object.oid, path, 504 &e->stages[1].oid, &e->stages[1].mode); 505 get_tree_entry_if_blob(&a->object.oid, path, 506 &e->stages[2].oid, &e->stages[2].mode); 507 get_tree_entry_if_blob(&b->object.oid, path, 508 &e->stages[3].oid, &e->stages[3].mode); 509 item = string_list_insert(entries, path); 510 item->util = e; 511 return e; 512} 513 514/* 515 * Create a dictionary mapping file names to stage_data objects. The 516 * dictionary contains one entry for every path with a non-zero stage entry. 517 */ 518static struct string_list *get_unmerged(struct index_state *istate) 519{ 520 struct string_list *unmerged = xcalloc(1, sizeof(struct string_list)); 521 int i; 522 523 unmerged->strdup_strings = 1; 524 525 for (i = 0; i < istate->cache_nr; i++) { 526 struct string_list_item *item; 527 struct stage_data *e; 528 const struct cache_entry *ce = istate->cache[i]; 529 if (!ce_stage(ce)) 530 continue; 531 532 item = string_list_lookup(unmerged, ce->name); 533 if (!item) { 534 item = string_list_insert(unmerged, ce->name); 535 item->util = xcalloc(1, sizeof(struct stage_data)); 536 } 537 e = item->util; 538 e->stages[ce_stage(ce)].mode = ce->ce_mode; 539 oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 540 } 541 542 return unmerged; 543} 544 545static int string_list_df_name_compare(const char *one, const char *two) 546{ 547 int onelen = strlen(one); 548 int twolen = strlen(two); 549 /* 550 * Here we only care that entries for D/F conflicts are 551 * adjacent, in particular with the file of the D/F conflict 552 * appearing before files below the corresponding directory. 553 * The order of the rest of the list is irrelevant for us. 554 * 555 * To achieve this, we sort with df_name_compare and provide 556 * the mode S_IFDIR so that D/F conflicts will sort correctly. 557 * We use the mode S_IFDIR for everything else for simplicity, 558 * since in other cases any changes in their order due to 559 * sorting cause no problems for us. 560 */ 561 int cmp = df_name_compare(one, onelen, S_IFDIR, 562 two, twolen, S_IFDIR); 563 /* 564 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 565 * that 'foo' comes before 'foo/bar'. 566 */ 567 if (cmp) 568 return cmp; 569 return onelen - twolen; 570} 571 572static void record_df_conflict_files(struct merge_options *o, 573 struct string_list *entries) 574{ 575 /* If there is a D/F conflict and the file for such a conflict 576 * currently exists in the working tree, we want to allow it to be 577 * removed to make room for the corresponding directory if needed. 578 * The files underneath the directories of such D/F conflicts will 579 * be processed before the corresponding file involved in the D/F 580 * conflict. If the D/F directory ends up being removed by the 581 * merge, then we won't have to touch the D/F file. If the D/F 582 * directory needs to be written to the working copy, then the D/F 583 * file will simply be removed (in make_room_for_path()) to make 584 * room for the necessary paths. Note that if both the directory 585 * and the file need to be present, then the D/F file will be 586 * reinstated with a new unique name at the time it is processed. 587 */ 588 struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 589 const char *last_file = NULL; 590 int last_len = 0; 591 int i; 592 593 /* 594 * If we're merging merge-bases, we don't want to bother with 595 * any working directory changes. 596 */ 597 if (o->call_depth) 598 return; 599 600 /* Ensure D/F conflicts are adjacent in the entries list. */ 601 for (i = 0; i < entries->nr; i++) { 602 struct string_list_item *next = &entries->items[i]; 603 string_list_append(&df_sorted_entries, next->string)->util = 604 next->util; 605 } 606 df_sorted_entries.cmp = string_list_df_name_compare; 607 string_list_sort(&df_sorted_entries); 608 609 string_list_clear(&o->df_conflict_file_set, 1); 610 for (i = 0; i < df_sorted_entries.nr; i++) { 611 const char *path = df_sorted_entries.items[i].string; 612 int len = strlen(path); 613 struct stage_data *e = df_sorted_entries.items[i].util; 614 615 /* 616 * Check if last_file & path correspond to a D/F conflict; 617 * i.e. whether path is last_file+'/'+<something>. 618 * If so, record that it's okay to remove last_file to make 619 * room for path and friends if needed. 620 */ 621 if (last_file && 622 len > last_len && 623 memcmp(path, last_file, last_len) == 0 && 624 path[last_len] == '/') { 625 string_list_insert(&o->df_conflict_file_set, last_file); 626 } 627 628 /* 629 * Determine whether path could exist as a file in the 630 * working directory as a possible D/F conflict. This 631 * will only occur when it exists in stage 2 as a 632 * file. 633 */ 634 if (S_ISREG(e->stages[2].mode) || S_ISLNK(e->stages[2].mode)) { 635 last_file = path; 636 last_len = len; 637 } else { 638 last_file = NULL; 639 } 640 } 641 string_list_clear(&df_sorted_entries, 0); 642} 643 644struct rename { 645 struct diff_filepair *pair; 646 /* 647 * Purpose of src_entry and dst_entry: 648 * 649 * If 'before' is renamed to 'after' then src_entry will contain 650 * the versions of 'before' from the merge_base, HEAD, and MERGE in 651 * stages 1, 2, and 3; dst_entry will contain the respective 652 * versions of 'after' in corresponding locations. Thus, we have a 653 * total of six modes and oids, though some will be null. (Stage 0 654 * is ignored; we're interested in handling conflicts.) 655 * 656 * Since we don't turn on break-rewrites by default, neither 657 * src_entry nor dst_entry can have all three of their stages have 658 * non-null oids, meaning at most four of the six will be non-null. 659 * Also, since this is a rename, both src_entry and dst_entry will 660 * have at least one non-null oid, meaning at least two will be 661 * non-null. Of the six oids, a typical rename will have three be 662 * non-null. Only two implies a rename/delete, and four implies a 663 * rename/add. 664 */ 665 struct stage_data *src_entry; 666 struct stage_data *dst_entry; 667 unsigned add_turned_into_rename:1; 668 unsigned processed:1; 669}; 670 671static int update_stages(struct merge_options *opt, const char *path, 672 const struct diff_filespec *o, 673 const struct diff_filespec *a, 674 const struct diff_filespec *b) 675{ 676 677 /* 678 * NOTE: It is usually a bad idea to call update_stages on a path 679 * before calling update_file on that same path, since it can 680 * sometimes lead to spurious "refusing to lose untracked file..." 681 * messages from update_file (via make_room_for path via 682 * would_lose_untracked). Instead, reverse the order of the calls 683 * (executing update_file first and then update_stages). 684 */ 685 int clear = 1; 686 int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 687 if (clear) 688 if (remove_file_from_index(opt->repo->index, path)) 689 return -1; 690 if (o) 691 if (add_cacheinfo(opt, o->mode, &o->oid, path, 1, 0, options)) 692 return -1; 693 if (a) 694 if (add_cacheinfo(opt, a->mode, &a->oid, path, 2, 0, options)) 695 return -1; 696 if (b) 697 if (add_cacheinfo(opt, b->mode, &b->oid, path, 3, 0, options)) 698 return -1; 699 return 0; 700} 701 702static void update_entry(struct stage_data *entry, 703 struct diff_filespec *o, 704 struct diff_filespec *a, 705 struct diff_filespec *b) 706{ 707 entry->processed = 0; 708 entry->stages[1].mode = o->mode; 709 entry->stages[2].mode = a->mode; 710 entry->stages[3].mode = b->mode; 711 oidcpy(&entry->stages[1].oid, &o->oid); 712 oidcpy(&entry->stages[2].oid, &a->oid); 713 oidcpy(&entry->stages[3].oid, &b->oid); 714} 715 716static int remove_file(struct merge_options *o, int clean, 717 const char *path, int no_wd) 718{ 719 int update_cache = o->call_depth || clean; 720 int update_working_directory = !o->call_depth && !no_wd; 721 722 if (update_cache) { 723 if (remove_file_from_index(o->repo->index, path)) 724 return -1; 725 } 726 if (update_working_directory) { 727 if (ignore_case) { 728 struct cache_entry *ce; 729 ce = index_file_exists(o->repo->index, path, strlen(path), 730 ignore_case); 731 if (ce && ce_stage(ce) == 0 && strcmp(path, ce->name)) 732 return 0; 733 } 734 if (remove_path(path)) 735 return -1; 736 } 737 return 0; 738} 739 740/* add a string to a strbuf, but converting "/" to "_" */ 741static void add_flattened_path(struct strbuf *out, const char *s) 742{ 743 size_t i = out->len; 744 strbuf_addstr(out, s); 745 for (; i < out->len; i++) 746 if (out->buf[i] == '/') 747 out->buf[i] = '_'; 748} 749 750static char *unique_path(struct merge_options *o, const char *path, const char *branch) 751{ 752 struct path_hashmap_entry *entry; 753 struct strbuf newpath = STRBUF_INIT; 754 int suffix = 0; 755 size_t base_len; 756 757 strbuf_addf(&newpath, "%s~", path); 758 add_flattened_path(&newpath, branch); 759 760 base_len = newpath.len; 761 while (hashmap_get_from_hash(&o->current_file_dir_set, 762 path_hash(newpath.buf), newpath.buf) || 763 (!o->call_depth && file_exists(newpath.buf))) { 764 strbuf_setlen(&newpath, base_len); 765 strbuf_addf(&newpath, "_%d", suffix++); 766 } 767 768 FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 769 hashmap_entry_init(entry, path_hash(entry->path)); 770 hashmap_add(&o->current_file_dir_set, entry); 771 return strbuf_detach(&newpath, NULL); 772} 773 774/** 775 * Check whether a directory in the index is in the way of an incoming 776 * file. Return 1 if so. If check_working_copy is non-zero, also 777 * check the working directory. If empty_ok is non-zero, also return 778 * 0 in the case where the working-tree dir exists but is empty. 779 */ 780static int dir_in_way(struct index_state *istate, const char *path, 781 int check_working_copy, int empty_ok) 782{ 783 int pos; 784 struct strbuf dirpath = STRBUF_INIT; 785 struct stat st; 786 787 strbuf_addstr(&dirpath, path); 788 strbuf_addch(&dirpath, '/'); 789 790 pos = index_name_pos(istate, dirpath.buf, dirpath.len); 791 792 if (pos < 0) 793 pos = -1 - pos; 794 if (pos < istate->cache_nr && 795 !strncmp(dirpath.buf, istate->cache[pos]->name, dirpath.len)) { 796 strbuf_release(&dirpath); 797 return 1; 798 } 799 800 strbuf_release(&dirpath); 801 return check_working_copy && !lstat(path, &st) && S_ISDIR(st.st_mode) && 802 !(empty_ok && is_empty_dir(path)); 803} 804 805/* 806 * Returns whether path was tracked in the index before the merge started, 807 * and its oid and mode match the specified values 808 */ 809static int was_tracked_and_matches(struct merge_options *o, const char *path, 810 const struct object_id *oid, unsigned mode) 811{ 812 int pos = index_name_pos(&o->orig_index, path, strlen(path)); 813 struct cache_entry *ce; 814 815 if (0 > pos) 816 /* we were not tracking this path before the merge */ 817 return 0; 818 819 /* See if the file we were tracking before matches */ 820 ce = o->orig_index.cache[pos]; 821 return (oid_eq(&ce->oid, oid) && ce->ce_mode == mode); 822} 823 824/* 825 * Returns whether path was tracked in the index before the merge started 826 */ 827static int was_tracked(struct merge_options *o, const char *path) 828{ 829 int pos = index_name_pos(&o->orig_index, path, strlen(path)); 830 831 if (0 <= pos) 832 /* we were tracking this path before the merge */ 833 return 1; 834 835 return 0; 836} 837 838static int would_lose_untracked(struct merge_options *o, const char *path) 839{ 840 struct index_state *istate = o->repo->index; 841 842 /* 843 * This may look like it can be simplified to: 844 * return !was_tracked(o, path) && file_exists(path) 845 * but it can't. This function needs to know whether path was in 846 * the working tree due to EITHER having been tracked in the index 847 * before the merge OR having been put into the working copy and 848 * index by unpack_trees(). Due to that either-or requirement, we 849 * check the current index instead of the original one. 850 * 851 * Note that we do not need to worry about merge-recursive itself 852 * updating the index after unpack_trees() and before calling this 853 * function, because we strictly require all code paths in 854 * merge-recursive to update the working tree first and the index 855 * second. Doing otherwise would break 856 * update_file()/would_lose_untracked(); see every comment in this 857 * file which mentions "update_stages". 858 */ 859 int pos = index_name_pos(istate, path, strlen(path)); 860 861 if (pos < 0) 862 pos = -1 - pos; 863 while (pos < istate->cache_nr && 864 !strcmp(path, istate->cache[pos]->name)) { 865 /* 866 * If stage #0, it is definitely tracked. 867 * If it has stage #2 then it was tracked 868 * before this merge started. All other 869 * cases the path was not tracked. 870 */ 871 switch (ce_stage(istate->cache[pos])) { 872 case 0: 873 case 2: 874 return 0; 875 } 876 pos++; 877 } 878 return file_exists(path); 879} 880 881static int was_dirty(struct merge_options *o, const char *path) 882{ 883 struct cache_entry *ce; 884 int dirty = 1; 885 886 if (o->call_depth || !was_tracked(o, path)) 887 return !dirty; 888 889 ce = index_file_exists(o->unpack_opts.src_index, 890 path, strlen(path), ignore_case); 891 dirty = verify_uptodate(ce, &o->unpack_opts) != 0; 892 return dirty; 893} 894 895static int make_room_for_path(struct merge_options *o, const char *path) 896{ 897 int status, i; 898 const char *msg = _("failed to create path '%s'%s"); 899 900 /* Unlink any D/F conflict files that are in the way */ 901 for (i = 0; i < o->df_conflict_file_set.nr; i++) { 902 const char *df_path = o->df_conflict_file_set.items[i].string; 903 size_t pathlen = strlen(path); 904 size_t df_pathlen = strlen(df_path); 905 if (df_pathlen < pathlen && 906 path[df_pathlen] == '/' && 907 strncmp(path, df_path, df_pathlen) == 0) { 908 output(o, 3, 909 _("Removing %s to make room for subdirectory\n"), 910 df_path); 911 unlink(df_path); 912 unsorted_string_list_delete_item(&o->df_conflict_file_set, 913 i, 0); 914 break; 915 } 916 } 917 918 /* Make sure leading directories are created */ 919 status = safe_create_leading_directories_const(path); 920 if (status) { 921 if (status == SCLD_EXISTS) 922 /* something else exists */ 923 return err(o, msg, path, _(": perhaps a D/F conflict?")); 924 return err(o, msg, path, ""); 925 } 926 927 /* 928 * Do not unlink a file in the work tree if we are not 929 * tracking it. 930 */ 931 if (would_lose_untracked(o, path)) 932 return err(o, _("refusing to lose untracked file at '%s'"), 933 path); 934 935 /* Successful unlink is good.. */ 936 if (!unlink(path)) 937 return 0; 938 /* .. and so is no existing file */ 939 if (errno == ENOENT) 940 return 0; 941 /* .. but not some other error (who really cares what?) */ 942 return err(o, msg, path, _(": perhaps a D/F conflict?")); 943} 944 945static int update_file_flags(struct merge_options *o, 946 const struct object_id *oid, 947 unsigned mode, 948 const char *path, 949 int update_cache, 950 int update_wd) 951{ 952 int ret = 0; 953 954 if (o->call_depth) 955 update_wd = 0; 956 957 if (update_wd) { 958 enum object_type type; 959 void *buf; 960 unsigned long size; 961 962 if (S_ISGITLINK(mode)) { 963 /* 964 * We may later decide to recursively descend into 965 * the submodule directory and update its index 966 * and/or work tree, but we do not do that now. 967 */ 968 update_wd = 0; 969 goto update_index; 970 } 971 972 buf = read_object_file(oid, &type, &size); 973 if (!buf) 974 return err(o, _("cannot read object %s '%s'"), oid_to_hex(oid), path); 975 if (type != OBJ_BLOB) { 976 ret = err(o, _("blob expected for %s '%s'"), oid_to_hex(oid), path); 977 goto free_buf; 978 } 979 if (S_ISREG(mode)) { 980 struct strbuf strbuf = STRBUF_INIT; 981 if (convert_to_working_tree(o->repo->index, path, buf, size, &strbuf)) { 982 free(buf); 983 size = strbuf.len; 984 buf = strbuf_detach(&strbuf, NULL); 985 } 986 } 987 988 if (make_room_for_path(o, path) < 0) { 989 update_wd = 0; 990 goto free_buf; 991 } 992 if (S_ISREG(mode) || (!has_symlinks && S_ISLNK(mode))) { 993 int fd; 994 if (mode & 0100) 995 mode = 0777; 996 else 997 mode = 0666; 998 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 999 if (fd < 0) {1000 ret = err(o, _("failed to open '%s': %s"),1001 path, strerror(errno));1002 goto free_buf;1003 }1004 write_in_full(fd, buf, size);1005 close(fd);1006 } else if (S_ISLNK(mode)) {1007 char *lnk = xmemdupz(buf, size);1008 safe_create_leading_directories_const(path);1009 unlink(path);1010 if (symlink(lnk, path))1011 ret = err(o, _("failed to symlink '%s': %s"),1012 path, strerror(errno));1013 free(lnk);1014 } else1015 ret = err(o,1016 _("do not know what to do with %06o %s '%s'"),1017 mode, oid_to_hex(oid), path);1018 free_buf:1019 free(buf);1020 }1021update_index:1022 if (!ret && update_cache)1023 if (add_cacheinfo(o, mode, oid, path, 0, update_wd,1024 ADD_CACHE_OK_TO_ADD))1025 return -1;1026 return ret;1027}10281029static int update_file(struct merge_options *o,1030 int clean,1031 const struct object_id *oid,1032 unsigned mode,1033 const char *path)1034{1035 return update_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth);1036}10371038/* Low level file merging, update and removal */10391040struct merge_file_info {1041 struct object_id oid;1042 unsigned mode;1043 unsigned clean:1,1044 merge:1;1045};10461047static int merge_3way(struct merge_options *o,1048 mmbuffer_t *result_buf,1049 const struct diff_filespec *one,1050 const struct diff_filespec *a,1051 const struct diff_filespec *b,1052 const char *branch1,1053 const char *branch2,1054 const int extra_marker_size)1055{1056 mmfile_t orig, src1, src2;1057 struct ll_merge_options ll_opts = {0};1058 char *base_name, *name1, *name2;1059 int merge_status;10601061 ll_opts.renormalize = o->renormalize;1062 ll_opts.extra_marker_size = extra_marker_size;1063 ll_opts.xdl_opts = o->xdl_opts;10641065 if (o->call_depth) {1066 ll_opts.virtual_ancestor = 1;1067 ll_opts.variant = 0;1068 } else {1069 switch (o->recursive_variant) {1070 case MERGE_RECURSIVE_OURS:1071 ll_opts.variant = XDL_MERGE_FAVOR_OURS;1072 break;1073 case MERGE_RECURSIVE_THEIRS:1074 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;1075 break;1076 default:1077 ll_opts.variant = 0;1078 break;1079 }1080 }10811082 if (strcmp(a->path, b->path) ||1083 (o->ancestor != NULL && strcmp(a->path, one->path) != 0)) {1084 base_name = o->ancestor == NULL ? NULL :1085 mkpathdup("%s:%s", o->ancestor, one->path);1086 name1 = mkpathdup("%s:%s", branch1, a->path);1087 name2 = mkpathdup("%s:%s", branch2, b->path);1088 } else {1089 base_name = o->ancestor == NULL ? NULL :1090 mkpathdup("%s", o->ancestor);1091 name1 = mkpathdup("%s", branch1);1092 name2 = mkpathdup("%s", branch2);1093 }10941095 read_mmblob(&orig, &one->oid);1096 read_mmblob(&src1, &a->oid);1097 read_mmblob(&src2, &b->oid);10981099 merge_status = ll_merge(result_buf, a->path, &orig, base_name,1100 &src1, name1, &src2, name2,1101 o->repo->index, &ll_opts);11021103 free(base_name);1104 free(name1);1105 free(name2);1106 free(orig.ptr);1107 free(src1.ptr);1108 free(src2.ptr);1109 return merge_status;1110}11111112static int find_first_merges(struct repository *repo,1113 struct object_array *result, const char *path,1114 struct commit *a, struct commit *b)1115{1116 int i, j;1117 struct object_array merges = OBJECT_ARRAY_INIT;1118 struct commit *commit;1119 int contains_another;11201121 char merged_revision[42];1122 const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",1123 "--all", merged_revision, NULL };1124 struct rev_info revs;1125 struct setup_revision_opt rev_opts;11261127 memset(result, 0, sizeof(struct object_array));1128 memset(&rev_opts, 0, sizeof(rev_opts));11291130 /* get all revisions that merge commit a */1131 xsnprintf(merged_revision, sizeof(merged_revision), "^%s",1132 oid_to_hex(&a->object.oid));1133 repo_init_revisions(repo, &revs, NULL);1134 rev_opts.submodule = path;1135 /* FIXME: can't handle linked worktrees in submodules yet */1136 revs.single_worktree = path != NULL;1137 setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);11381139 /* save all revisions from the above list that contain b */1140 if (prepare_revision_walk(&revs))1141 die("revision walk setup failed");1142 while ((commit = get_revision(&revs)) != NULL) {1143 struct object *o = &(commit->object);1144 if (in_merge_bases(b, commit))1145 add_object_array(o, NULL, &merges);1146 }1147 reset_revision_walk();11481149 /* Now we've got all merges that contain a and b. Prune all1150 * merges that contain another found merge and save them in1151 * result.1152 */1153 for (i = 0; i < merges.nr; i++) {1154 struct commit *m1 = (struct commit *) merges.objects[i].item;11551156 contains_another = 0;1157 for (j = 0; j < merges.nr; j++) {1158 struct commit *m2 = (struct commit *) merges.objects[j].item;1159 if (i != j && in_merge_bases(m2, m1)) {1160 contains_another = 1;1161 break;1162 }1163 }11641165 if (!contains_another)1166 add_object_array(merges.objects[i].item, NULL, result);1167 }11681169 object_array_clear(&merges);1170 return result->nr;1171}11721173static void print_commit(struct commit *commit)1174{1175 struct strbuf sb = STRBUF_INIT;1176 struct pretty_print_context ctx = {0};1177 ctx.date_mode.type = DATE_NORMAL;1178 format_commit_message(commit, " %h: %m %s", &sb, &ctx);1179 fprintf(stderr, "%s\n", sb.buf);1180 strbuf_release(&sb);1181}11821183static int merge_submodule(struct merge_options *o,1184 struct object_id *result, const char *path,1185 const struct object_id *base, const struct object_id *a,1186 const struct object_id *b)1187{1188 struct commit *commit_base, *commit_a, *commit_b;1189 int parent_count;1190 struct object_array merges;11911192 int i;1193 int search = !o->call_depth;11941195 /* store a in result in case we fail */1196 oidcpy(result, a);11971198 /* we can not handle deletion conflicts */1199 if (is_null_oid(base))1200 return 0;1201 if (is_null_oid(a))1202 return 0;1203 if (is_null_oid(b))1204 return 0;12051206 if (add_submodule_odb(path)) {1207 output(o, 1, _("Failed to merge submodule %s (not checked out)"), path);1208 return 0;1209 }12101211 if (!(commit_base = lookup_commit_reference(the_repository, base)) ||1212 !(commit_a = lookup_commit_reference(the_repository, a)) ||1213 !(commit_b = lookup_commit_reference(the_repository, b))) {1214 output(o, 1, _("Failed to merge submodule %s (commits not present)"), path);1215 return 0;1216 }12171218 /* check whether both changes are forward */1219 if (!in_merge_bases(commit_base, commit_a) ||1220 !in_merge_bases(commit_base, commit_b)) {1221 output(o, 1, _("Failed to merge submodule %s (commits don't follow merge-base)"), path);1222 return 0;1223 }12241225 /* Case #1: a is contained in b or vice versa */1226 if (in_merge_bases(commit_a, commit_b)) {1227 oidcpy(result, b);1228 if (show(o, 3)) {1229 output(o, 3, _("Fast-forwarding submodule %s to the following commit:"), path);1230 output_commit_title(o, commit_b);1231 } else if (show(o, 2))1232 output(o, 2, _("Fast-forwarding submodule %s"), path);1233 else1234 ; /* no output */12351236 return 1;1237 }1238 if (in_merge_bases(commit_b, commit_a)) {1239 oidcpy(result, a);1240 if (show(o, 3)) {1241 output(o, 3, _("Fast-forwarding submodule %s to the following commit:"), path);1242 output_commit_title(o, commit_a);1243 } else if (show(o, 2))1244 output(o, 2, _("Fast-forwarding submodule %s"), path);1245 else1246 ; /* no output */12471248 return 1;1249 }12501251 /*1252 * Case #2: There are one or more merges that contain a and b in1253 * the submodule. If there is only one, then present it as a1254 * suggestion to the user, but leave it marked unmerged so the1255 * user needs to confirm the resolution.1256 */12571258 /* Skip the search if makes no sense to the calling context. */1259 if (!search)1260 return 0;12611262 /* find commit which merges them */1263 parent_count = find_first_merges(o->repo, &merges, path,1264 commit_a, commit_b);1265 switch (parent_count) {1266 case 0:1267 output(o, 1, _("Failed to merge submodule %s (merge following commits not found)"), path);1268 break;12691270 case 1:1271 output(o, 1, _("Failed to merge submodule %s (not fast-forward)"), path);1272 output(o, 2, _("Found a possible merge resolution for the submodule:\n"));1273 print_commit((struct commit *) merges.objects[0].item);1274 output(o, 2, _(1275 "If this is correct simply add it to the index "1276 "for example\n"1277 "by using:\n\n"1278 " git update-index --cacheinfo 160000 %s \"%s\"\n\n"1279 "which will accept this suggestion.\n"),1280 oid_to_hex(&merges.objects[0].item->oid), path);1281 break;12821283 default:1284 output(o, 1, _("Failed to merge submodule %s (multiple merges found)"), path);1285 for (i = 0; i < merges.nr; i++)1286 print_commit((struct commit *) merges.objects[i].item);1287 }12881289 object_array_clear(&merges);1290 return 0;1291}12921293static int merge_mode_and_contents(struct merge_options *o,1294 const struct diff_filespec *one,1295 const struct diff_filespec *a,1296 const struct diff_filespec *b,1297 const char *filename,1298 const char *branch1,1299 const char *branch2,1300 const int extra_marker_size,1301 struct merge_file_info *result)1302{1303 if (o->branch1 != branch1) {1304 /*1305 * It's weird getting a reverse merge with HEAD on the bottom1306 * side of the conflict markers and the other branch on the1307 * top. Fix that.1308 */1309 return merge_mode_and_contents(o, one, b, a,1310 filename,1311 branch2, branch1,1312 extra_marker_size, result);1313 }13141315 result->merge = 0;1316 result->clean = 1;13171318 if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {1319 result->clean = 0;1320 if (S_ISREG(a->mode)) {1321 result->mode = a->mode;1322 oidcpy(&result->oid, &a->oid);1323 } else {1324 result->mode = b->mode;1325 oidcpy(&result->oid, &b->oid);1326 }1327 } else {1328 if (!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))1329 result->merge = 1;13301331 /*1332 * Merge modes1333 */1334 if (a->mode == b->mode || a->mode == one->mode)1335 result->mode = b->mode;1336 else {1337 result->mode = a->mode;1338 if (b->mode != one->mode) {1339 result->clean = 0;1340 result->merge = 1;1341 }1342 }13431344 if (oid_eq(&a->oid, &b->oid) || oid_eq(&a->oid, &one->oid))1345 oidcpy(&result->oid, &b->oid);1346 else if (oid_eq(&b->oid, &one->oid))1347 oidcpy(&result->oid, &a->oid);1348 else if (S_ISREG(a->mode)) {1349 mmbuffer_t result_buf;1350 int ret = 0, merge_status;13511352 merge_status = merge_3way(o, &result_buf, one, a, b,1353 branch1, branch2,1354 extra_marker_size);13551356 if ((merge_status < 0) || !result_buf.ptr)1357 ret = err(o, _("Failed to execute internal merge"));13581359 if (!ret &&1360 write_object_file(result_buf.ptr, result_buf.size,1361 blob_type, &result->oid))1362 ret = err(o, _("Unable to add %s to database"),1363 a->path);13641365 free(result_buf.ptr);1366 if (ret)1367 return ret;1368 result->clean = (merge_status == 0);1369 } else if (S_ISGITLINK(a->mode)) {1370 result->clean = merge_submodule(o, &result->oid,1371 one->path,1372 &one->oid,1373 &a->oid,1374 &b->oid);1375 } else if (S_ISLNK(a->mode)) {1376 switch (o->recursive_variant) {1377 case MERGE_RECURSIVE_NORMAL:1378 oidcpy(&result->oid, &a->oid);1379 if (!oid_eq(&a->oid, &b->oid))1380 result->clean = 0;1381 break;1382 case MERGE_RECURSIVE_OURS:1383 oidcpy(&result->oid, &a->oid);1384 break;1385 case MERGE_RECURSIVE_THEIRS:1386 oidcpy(&result->oid, &b->oid);1387 break;1388 }1389 } else1390 BUG("unsupported object type in the tree");1391 }13921393 if (result->merge)1394 output(o, 2, _("Auto-merging %s"), filename);13951396 return 0;1397}13981399static int handle_rename_via_dir(struct merge_options *o,1400 struct diff_filepair *pair,1401 const char *rename_branch,1402 const char *other_branch)1403{1404 /*1405 * Handle file adds that need to be renamed due to directory rename1406 * detection. This differs from handle_rename_normal, because1407 * there is no content merge to do; just move the file into the1408 * desired final location.1409 */1410 const struct diff_filespec *dest = pair->two;14111412 if (!o->call_depth && would_lose_untracked(o, dest->path)) {1413 char *alt_path = unique_path(o, dest->path, rename_branch);14141415 output(o, 1, _("Error: Refusing to lose untracked file at %s; "1416 "writing to %s instead."),1417 dest->path, alt_path);1418 /*1419 * Write the file in worktree at alt_path, but not in the1420 * index. Instead, write to dest->path for the index but1421 * only at the higher appropriate stage.1422 */1423 if (update_file(o, 0, &dest->oid, dest->mode, alt_path))1424 return -1;1425 free(alt_path);1426 return update_stages(o, dest->path, NULL,1427 rename_branch == o->branch1 ? dest : NULL,1428 rename_branch == o->branch1 ? NULL : dest);1429 }14301431 /* Update dest->path both in index and in worktree */1432 if (update_file(o, 1, &dest->oid, dest->mode, dest->path))1433 return -1;1434 return 0;1435}14361437static int handle_change_delete(struct merge_options *o,1438 const char *path, const char *old_path,1439 const struct object_id *o_oid, int o_mode,1440 const struct object_id *changed_oid,1441 int changed_mode,1442 const char *change_branch,1443 const char *delete_branch,1444 const char *change, const char *change_past)1445{1446 char *alt_path = NULL;1447 const char *update_path = path;1448 int ret = 0;14491450 if (dir_in_way(o->repo->index, path, !o->call_depth, 0) ||1451 (!o->call_depth && would_lose_untracked(o, path))) {1452 update_path = alt_path = unique_path(o, path, change_branch);1453 }14541455 if (o->call_depth) {1456 /*1457 * We cannot arbitrarily accept either a_sha or b_sha as1458 * correct; since there is no true "middle point" between1459 * them, simply reuse the base version for virtual merge base.1460 */1461 ret = remove_file_from_index(o->repo->index, path);1462 if (!ret)1463 ret = update_file(o, 0, o_oid, o_mode, update_path);1464 } else {1465 /*1466 * Despite the four nearly duplicate messages and argument1467 * lists below and the ugliness of the nested if-statements,1468 * having complete messages makes the job easier for1469 * translators.1470 *1471 * The slight variance among the cases is due to the fact1472 * that:1473 * 1) directory/file conflicts (in effect if1474 * !alt_path) could cause us to need to write the1475 * file to a different path.1476 * 2) renames (in effect if !old_path) could mean that1477 * there are two names for the path that the user1478 * may know the file by.1479 */1480 if (!alt_path) {1481 if (!old_path) {1482 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "1483 "and %s in %s. Version %s of %s left in tree."),1484 change, path, delete_branch, change_past,1485 change_branch, change_branch, path);1486 } else {1487 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "1488 "and %s to %s in %s. Version %s of %s left in tree."),1489 change, old_path, delete_branch, change_past, path,1490 change_branch, change_branch, path);1491 }1492 } else {1493 if (!old_path) {1494 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "1495 "and %s in %s. Version %s of %s left in tree at %s."),1496 change, path, delete_branch, change_past,1497 change_branch, change_branch, path, alt_path);1498 } else {1499 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "1500 "and %s to %s in %s. Version %s of %s left in tree at %s."),1501 change, old_path, delete_branch, change_past, path,1502 change_branch, change_branch, path, alt_path);1503 }1504 }1505 /*1506 * No need to call update_file() on path when change_branch ==1507 * o->branch1 && !alt_path, since that would needlessly touch1508 * path. We could call update_file_flags() with update_cache=01509 * and update_wd=0, but that's a no-op.1510 */1511 if (change_branch != o->branch1 || alt_path)1512 ret = update_file(o, 0, changed_oid, changed_mode, update_path);1513 }1514 free(alt_path);15151516 return ret;1517}15181519static int handle_rename_delete(struct merge_options *o,1520 struct diff_filepair *pair,1521 const char *rename_branch,1522 const char *delete_branch)1523{1524 const struct diff_filespec *orig = pair->one;1525 const struct diff_filespec *dest = pair->two;15261527 if (handle_change_delete(o,1528 o->call_depth ? orig->path : dest->path,1529 o->call_depth ? NULL : orig->path,1530 &orig->oid, orig->mode,1531 &dest->oid, dest->mode,1532 rename_branch, delete_branch,1533 _("rename"), _("renamed")))1534 return -1;15351536 if (o->call_depth)1537 return remove_file_from_index(o->repo->index, dest->path);1538 else1539 return update_stages(o, dest->path, NULL,1540 rename_branch == o->branch1 ? dest : NULL,1541 rename_branch == o->branch1 ? NULL : dest);1542}15431544static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,1545 struct stage_data *entry,1546 int stage)1547{1548 struct object_id *oid = &entry->stages[stage].oid;1549 unsigned mode = entry->stages[stage].mode;1550 if (mode == 0 || is_null_oid(oid))1551 return NULL;1552 oidcpy(&target->oid, oid);1553 target->mode = mode;1554 return target;1555}15561557static int handle_file_collision(struct merge_options *o,1558 const char *collide_path,1559 const char *prev_path1,1560 const char *prev_path2,1561 const char *branch1, const char *branch2,1562 const struct object_id *a_oid,1563 unsigned int a_mode,1564 const struct object_id *b_oid,1565 unsigned int b_mode)1566{1567 struct merge_file_info mfi;1568 struct diff_filespec null, a, b;1569 char *alt_path = NULL;1570 const char *update_path = collide_path;15711572 /*1573 * It's easiest to get the correct things into stage 2 and 3, and1574 * to make sure that the content merge puts HEAD before the other1575 * branch if we just ensure that branch1 == o->branch1. So, simply1576 * flip arguments around if we don't have that.1577 */1578 if (branch1 != o->branch1) {1579 return handle_file_collision(o, collide_path,1580 prev_path2, prev_path1,1581 branch2, branch1,1582 b_oid, b_mode,1583 a_oid, a_mode);1584 }15851586 /*1587 * In the recursive case, we just opt to undo renames1588 */1589 if (o->call_depth && (prev_path1 || prev_path2)) {1590 /* Put first file (a_oid, a_mode) in its original spot */1591 if (prev_path1) {1592 if (update_file(o, 1, a_oid, a_mode, prev_path1))1593 return -1;1594 } else {1595 if (update_file(o, 1, a_oid, a_mode, collide_path))1596 return -1;1597 }15981599 /* Put second file (b_oid, b_mode) in its original spot */1600 if (prev_path2) {1601 if (update_file(o, 1, b_oid, b_mode, prev_path2))1602 return -1;1603 } else {1604 if (update_file(o, 1, b_oid, b_mode, collide_path))1605 return -1;1606 }16071608 /* Don't leave something at collision path if unrenaming both */1609 if (prev_path1 && prev_path2)1610 remove_file(o, 1, collide_path, 0);16111612 return 0;1613 }16141615 /* Remove rename sources if rename/add or rename/rename(2to1) */1616 if (prev_path1)1617 remove_file(o, 1, prev_path1,1618 o->call_depth || would_lose_untracked(o, prev_path1));1619 if (prev_path2)1620 remove_file(o, 1, prev_path2,1621 o->call_depth || would_lose_untracked(o, prev_path2));16221623 /*1624 * Remove the collision path, if it wouldn't cause dirty contents1625 * or an untracked file to get lost. We'll either overwrite with1626 * merged contents, or just write out to differently named files.1627 */1628 if (was_dirty(o, collide_path)) {1629 output(o, 1, _("Refusing to lose dirty file at %s"),1630 collide_path);1631 update_path = alt_path = unique_path(o, collide_path, "merged");1632 } else if (would_lose_untracked(o, collide_path)) {1633 /*1634 * Only way we get here is if both renames were from1635 * a directory rename AND user had an untracked file1636 * at the location where both files end up after the1637 * two directory renames. See testcase 10d of t6043.1638 */1639 output(o, 1, _("Refusing to lose untracked file at "1640 "%s, even though it's in the way."),1641 collide_path);1642 update_path = alt_path = unique_path(o, collide_path, "merged");1643 } else {1644 /*1645 * FIXME: It's possible that the two files are identical1646 * and that the current working copy happens to match, in1647 * which case we are unnecessarily touching the working1648 * tree file. It's not a likely enough scenario that I1649 * want to code up the checks for it and a better fix is1650 * available if we restructure how unpack_trees() and1651 * merge-recursive interoperate anyway, so punting for1652 * now...1653 */1654 remove_file(o, 0, collide_path, 0);1655 }16561657 /* Store things in diff_filespecs for functions that need it */1658 memset(&a, 0, sizeof(struct diff_filespec));1659 memset(&b, 0, sizeof(struct diff_filespec));1660 null.path = a.path = b.path = (char *)collide_path;1661 oidcpy(&null.oid, &null_oid);1662 null.mode = 0;1663 oidcpy(&a.oid, a_oid);1664 a.mode = a_mode;1665 a.oid_valid = 1;1666 oidcpy(&b.oid, b_oid);1667 b.mode = b_mode;1668 b.oid_valid = 1;16691670 if (merge_mode_and_contents(o, &null, &a, &b, collide_path,1671 branch1, branch2, o->call_depth * 2, &mfi))1672 return -1;1673 mfi.clean &= !alt_path;1674 if (update_file(o, mfi.clean, &mfi.oid, mfi.mode, update_path))1675 return -1;1676 if (!mfi.clean && !o->call_depth &&1677 update_stages(o, collide_path, NULL, &a, &b))1678 return -1;1679 free(alt_path);1680 /*1681 * FIXME: If both a & b both started with conflicts (only possible1682 * if they came from a rename/rename(2to1)), but had IDENTICAL1683 * contents including those conflicts, then in the next line we claim1684 * it was clean. If someone cares about this case, we should have the1685 * caller notify us if we started with conflicts.1686 */1687 return mfi.clean;1688}16891690static int handle_rename_add(struct merge_options *o,1691 struct rename_conflict_info *ci)1692{1693 /* a was renamed to c, and a separate c was added. */1694 struct diff_filespec *a = ci->pair1->one;1695 struct diff_filespec *c = ci->pair1->two;1696 char *path = c->path;1697 char *prev_path_desc;1698 struct merge_file_info mfi;16991700 int other_stage = (ci->branch1 == o->branch1 ? 3 : 2);17011702 output(o, 1, _("CONFLICT (rename/add): "1703 "Rename %s->%s in %s. Added %s in %s"),1704 a->path, c->path, ci->branch1,1705 c->path, ci->branch2);17061707 prev_path_desc = xstrfmt("version of %s from %s", path, a->path);1708 if (merge_mode_and_contents(o, a, c, &ci->ren1_other, prev_path_desc,1709 o->branch1, o->branch2,1710 1 + o->call_depth * 2, &mfi))1711 return -1;1712 free(prev_path_desc);17131714 return handle_file_collision(o,1715 c->path, a->path, NULL,1716 ci->branch1, ci->branch2,1717 &mfi.oid, mfi.mode,1718 &ci->dst_entry1->stages[other_stage].oid,1719 ci->dst_entry1->stages[other_stage].mode);1720}17211722static char *find_path_for_conflict(struct merge_options *o,1723 const char *path,1724 const char *branch1,1725 const char *branch2)1726{1727 char *new_path = NULL;1728 if (dir_in_way(o->repo->index, path, !o->call_depth, 0)) {1729 new_path = unique_path(o, path, branch1);1730 output(o, 1, _("%s is a directory in %s adding "1731 "as %s instead"),1732 path, branch2, new_path);1733 } else if (would_lose_untracked(o, path)) {1734 new_path = unique_path(o, path, branch1);1735 output(o, 1, _("Refusing to lose untracked file"1736 " at %s; adding as %s instead"),1737 path, new_path);1738 }17391740 return new_path;1741}17421743static int handle_rename_rename_1to2(struct merge_options *o,1744 struct rename_conflict_info *ci)1745{1746 /* One file was renamed in both branches, but to different names. */1747 struct merge_file_info mfi;1748 struct diff_filespec other;1749 struct diff_filespec *add;1750 struct diff_filespec *one = ci->pair1->one;1751 struct diff_filespec *a = ci->pair1->two;1752 struct diff_filespec *b = ci->pair2->two;1753 char *path_desc;17541755 output(o, 1, _("CONFLICT (rename/rename): "1756 "Rename \"%s\"->\"%s\" in branch \"%s\" "1757 "rename \"%s\"->\"%s\" in \"%s\"%s"),1758 one->path, a->path, ci->branch1,1759 one->path, b->path, ci->branch2,1760 o->call_depth ? _(" (left unresolved)") : "");17611762 path_desc = xstrfmt("%s and %s, both renamed from %s",1763 a->path, b->path, one->path);1764 if (merge_mode_and_contents(o, one, a, b, path_desc,1765 ci->branch1, ci->branch2,1766 o->call_depth * 2, &mfi))1767 return -1;1768 free(path_desc);17691770 if (o->call_depth) {1771 /*1772 * FIXME: For rename/add-source conflicts (if we could detect1773 * such), this is wrong. We should instead find a unique1774 * pathname and then either rename the add-source file to that1775 * unique path, or use that unique path instead of src here.1776 */1777 if (update_file(o, 0, &mfi.oid, mfi.mode, one->path))1778 return -1;17791780 /*1781 * Above, we put the merged content at the merge-base's1782 * path. Now we usually need to delete both a->path and1783 * b->path. However, the rename on each side of the merge1784 * could also be involved in a rename/add conflict. In1785 * such cases, we should keep the added file around,1786 * resolving the conflict at that path in its favor.1787 */1788 add = filespec_from_entry(&other, ci->dst_entry1, 2 ^ 1);1789 if (add) {1790 if (update_file(o, 0, &add->oid, add->mode, a->path))1791 return -1;1792 }1793 else1794 remove_file_from_index(o->repo->index, a->path);1795 add = filespec_from_entry(&other, ci->dst_entry2, 3 ^ 1);1796 if (add) {1797 if (update_file(o, 0, &add->oid, add->mode, b->path))1798 return -1;1799 }1800 else1801 remove_file_from_index(o->repo->index, b->path);1802 } else {1803 /*1804 * For each destination path, we need to see if there is a1805 * rename/add collision. If not, we can write the file out1806 * to the specified location.1807 */1808 add = filespec_from_entry(&other, ci->dst_entry1, 2 ^ 1);1809 if (add) {1810 if (handle_file_collision(o, a->path,1811 NULL, NULL,1812 ci->branch1, ci->branch2,1813 &mfi.oid, mfi.mode,1814 &add->oid, add->mode) < 0)1815 return -1;1816 } else {1817 char *new_path = find_path_for_conflict(o, a->path,1818 ci->branch1,1819 ci->branch2);1820 if (update_file(o, 0, &mfi.oid, mfi.mode, new_path ? new_path : a->path))1821 return -1;1822 free(new_path);1823 if (update_stages(o, a->path, NULL, a, NULL))1824 return -1;1825 }18261827 add = filespec_from_entry(&other, ci->dst_entry2, 3 ^ 1);1828 if (add) {1829 if (handle_file_collision(o, b->path,1830 NULL, NULL,1831 ci->branch1, ci->branch2,1832 &add->oid, add->mode,1833 &mfi.oid, mfi.mode) < 0)1834 return -1;1835 } else {1836 char *new_path = find_path_for_conflict(o, b->path,1837 ci->branch2,1838 ci->branch1);1839 if (update_file(o, 0, &mfi.oid, mfi.mode, new_path ? new_path : b->path))1840 return -1;1841 free(new_path);1842 if (update_stages(o, b->path, NULL, NULL, b))1843 return -1;1844 }1845 }18461847 return 0;1848}18491850static int handle_rename_rename_2to1(struct merge_options *o,1851 struct rename_conflict_info *ci)1852{1853 /* Two files, a & b, were renamed to the same thing, c. */1854 struct diff_filespec *a = ci->pair1->one;1855 struct diff_filespec *b = ci->pair2->one;1856 struct diff_filespec *c1 = ci->pair1->two;1857 struct diff_filespec *c2 = ci->pair2->two;1858 char *path = c1->path; /* == c2->path */1859 char *path_side_1_desc;1860 char *path_side_2_desc;1861 struct merge_file_info mfi_c1;1862 struct merge_file_info mfi_c2;18631864 output(o, 1, _("CONFLICT (rename/rename): "1865 "Rename %s->%s in %s. "1866 "Rename %s->%s in %s"),1867 a->path, c1->path, ci->branch1,1868 b->path, c2->path, ci->branch2);18691870 path_side_1_desc = xstrfmt("version of %s from %s", path, a->path);1871 path_side_2_desc = xstrfmt("version of %s from %s", path, b->path);1872 if (merge_mode_and_contents(o, a, c1, &ci->ren1_other, path_side_1_desc,1873 o->branch1, o->branch2,1874 1 + o->call_depth * 2, &mfi_c1) ||1875 merge_mode_and_contents(o, b, &ci->ren2_other, c2, path_side_2_desc,1876 o->branch1, o->branch2,1877 1 + o->call_depth * 2, &mfi_c2))1878 return -1;1879 free(path_side_1_desc);1880 free(path_side_2_desc);18811882 return handle_file_collision(o, path, a->path, b->path,1883 ci->branch1, ci->branch2,1884 &mfi_c1.oid, mfi_c1.mode,1885 &mfi_c2.oid, mfi_c2.mode);1886}18871888/*1889 * Get the diff_filepairs changed between o_tree and tree.1890 */1891static struct diff_queue_struct *get_diffpairs(struct merge_options *o,1892 struct tree *o_tree,1893 struct tree *tree)1894{1895 struct diff_queue_struct *ret;1896 struct diff_options opts;18971898 repo_diff_setup(o->repo, &opts);1899 opts.flags.recursive = 1;1900 opts.flags.rename_empty = 0;1901 opts.detect_rename = merge_detect_rename(o);1902 /*1903 * We do not have logic to handle the detection of copies. In1904 * fact, it may not even make sense to add such logic: would we1905 * really want a change to a base file to be propagated through1906 * multiple other files by a merge?1907 */1908 if (opts.detect_rename > DIFF_DETECT_RENAME)1909 opts.detect_rename = DIFF_DETECT_RENAME;1910 opts.rename_limit = o->merge_rename_limit >= 0 ? o->merge_rename_limit :1911 o->diff_rename_limit >= 0 ? o->diff_rename_limit :1912 1000;1913 opts.rename_score = o->rename_score;1914 opts.show_rename_progress = o->show_rename_progress;1915 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1916 diff_setup_done(&opts);1917 diff_tree_oid(&o_tree->object.oid, &tree->object.oid, "", &opts);1918 diffcore_std(&opts);1919 if (opts.needed_rename_limit > o->needed_rename_limit)1920 o->needed_rename_limit = opts.needed_rename_limit;19211922 ret = xmalloc(sizeof(*ret));1923 *ret = diff_queued_diff;19241925 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1926 diff_queued_diff.nr = 0;1927 diff_queued_diff.queue = NULL;1928 diff_flush(&opts);1929 return ret;1930}19311932static int tree_has_path(struct tree *tree, const char *path)1933{1934 struct object_id hashy;1935 unsigned int mode_o;19361937 return !get_tree_entry(&tree->object.oid, path,1938 &hashy, &mode_o);1939}19401941/*1942 * Return a new string that replaces the beginning portion (which matches1943 * entry->dir), with entry->new_dir. In perl-speak:1944 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1945 * NOTE:1946 * Caller must ensure that old_path starts with entry->dir + '/'.1947 */1948static char *apply_dir_rename(struct dir_rename_entry *entry,1949 const char *old_path)1950{1951 struct strbuf new_path = STRBUF_INIT;1952 int oldlen, newlen;19531954 if (entry->non_unique_new_dir)1955 return NULL;19561957 oldlen = strlen(entry->dir);1958 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) + 1;1959 strbuf_grow(&new_path, newlen);1960 strbuf_addbuf(&new_path, &entry->new_dir);1961 strbuf_addstr(&new_path, &old_path[oldlen]);19621963 return strbuf_detach(&new_path, NULL);1964}19651966static void get_renamed_dir_portion(const char *old_path, const char *new_path,1967 char **old_dir, char **new_dir)1968{1969 char *end_of_old, *end_of_new;1970 int old_len, new_len;19711972 *old_dir = NULL;1973 *new_dir = NULL;19741975 /*1976 * For1977 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1978 * the "e/foo.c" part is the same, we just want to know that1979 * "a/b/c/d" was renamed to "a/b/some/thing/else"1980 * so, for this example, this function returns "a/b/c/d" in1981 * *old_dir and "a/b/some/thing/else" in *new_dir.1982 *1983 * Also, if the basename of the file changed, we don't care. We1984 * want to know which portion of the directory, if any, changed.1985 */1986 end_of_old = strrchr(old_path, '/');1987 end_of_new = strrchr(new_path, '/');19881989 if (end_of_old == NULL || end_of_new == NULL)1990 return;1991 while (*--end_of_new == *--end_of_old &&1992 end_of_old != old_path &&1993 end_of_new != new_path)1994 ; /* Do nothing; all in the while loop */1995 /*1996 * We've found the first non-matching character in the directory1997 * paths. That means the current directory we were comparing1998 * represents the rename. Move end_of_old and end_of_new back1999 * to the full directory name.2000 */2001 if (*end_of_old == '/')2002 end_of_old++;2003 if (*end_of_old != '/')2004 end_of_new++;2005 end_of_old = strchr(end_of_old, '/');2006 end_of_new = strchr(end_of_new, '/');20072008 /*2009 * It may have been the case that old_path and new_path were the same2010 * directory all along. Don't claim a rename if they're the same.2011 */2012 old_len = end_of_old - old_path;2013 new_len = end_of_new - new_path;20142015 if (old_len != new_len || strncmp(old_path, new_path, old_len)) {2016 *old_dir = xstrndup(old_path, old_len);2017 *new_dir = xstrndup(new_path, new_len);2018 }2019}20202021static void remove_hashmap_entries(struct hashmap *dir_renames,2022 struct string_list *items_to_remove)2023{2024 int i;2025 struct dir_rename_entry *entry;20262027 for (i = 0; i < items_to_remove->nr; i++) {2028 entry = items_to_remove->items[i].util;2029 hashmap_remove(dir_renames, entry, NULL);2030 }2031 string_list_clear(items_to_remove, 0);2032}20332034/*2035 * See if there is a directory rename for path, and if there are any file2036 * level conflicts for the renamed location. If there is a rename and2037 * there are no conflicts, return the new name. Otherwise, return NULL.2038 */2039static char *handle_path_level_conflicts(struct merge_options *o,2040 const char *path,2041 struct dir_rename_entry *entry,2042 struct hashmap *collisions,2043 struct tree *tree)2044{2045 char *new_path = NULL;2046 struct collision_entry *collision_ent;2047 int clean = 1;2048 struct strbuf collision_paths = STRBUF_INIT;20492050 /*2051 * entry has the mapping of old directory name to new directory name2052 * that we want to apply to path.2053 */2054 new_path = apply_dir_rename(entry, path);20552056 if (!new_path) {2057 /* This should only happen when entry->non_unique_new_dir set */2058 if (!entry->non_unique_new_dir)2059 BUG("entry->non_unqiue_dir not set and !new_path");2060 output(o, 1, _("CONFLICT (directory rename split): "2061 "Unclear where to place %s because directory "2062 "%s was renamed to multiple other directories, "2063 "with no destination getting a majority of the "2064 "files."),2065 path, entry->dir);2066 clean = 0;2067 return NULL;2068 }20692070 /*2071 * The caller needs to have ensured that it has pre-populated2072 * collisions with all paths that map to new_path. Do a quick check2073 * to ensure that's the case.2074 */2075 collision_ent = collision_find_entry(collisions, new_path);2076 if (collision_ent == NULL)2077 BUG("collision_ent is NULL");20782079 /*2080 * Check for one-sided add/add/.../add conflicts, i.e.2081 * where implicit renames from the other side doing2082 * directory rename(s) can affect this side of history2083 * to put multiple paths into the same location. Warn2084 * and bail on directory renames for such paths.2085 */2086 if (collision_ent->reported_already) {2087 clean = 0;2088 } else if (tree_has_path(tree, new_path)) {2089 collision_ent->reported_already = 1;2090 strbuf_add_separated_string_list(&collision_paths, ", ",2091 &collision_ent->source_files);2092 output(o, 1, _("CONFLICT (implicit dir rename): Existing "2093 "file/dir at %s in the way of implicit "2094 "directory rename(s) putting the following "2095 "path(s) there: %s."),2096 new_path, collision_paths.buf);2097 clean = 0;2098 } else if (collision_ent->source_files.nr > 1) {2099 collision_ent->reported_already = 1;2100 strbuf_add_separated_string_list(&collision_paths, ", ",2101 &collision_ent->source_files);2102 output(o, 1, _("CONFLICT (implicit dir rename): Cannot map "2103 "more than one path to %s; implicit directory "2104 "renames tried to put these paths there: %s"),2105 new_path, collision_paths.buf);2106 clean = 0;2107 }21082109 /* Free memory we no longer need */2110 strbuf_release(&collision_paths);2111 if (!clean && new_path) {2112 free(new_path);2113 return NULL;2114 }21152116 return new_path;2117}21182119/*2120 * There are a couple things we want to do at the directory level:2121 * 1. Check for both sides renaming to the same thing, in order to avoid2122 * implicit renaming of files that should be left in place. (See2123 * testcase 6b in t6043 for details.)2124 * 2. Prune directory renames if there are still files left in the2125 * the original directory. These represent a partial directory rename,2126 * i.e. a rename where only some of the files within the directory2127 * were renamed elsewhere. (Technically, this could be done earlier2128 * in get_directory_renames(), except that would prevent us from2129 * doing the previous check and thus failing testcase 6b.)2130 * 3. Check for rename/rename(1to2) conflicts (at the directory level).2131 * In the future, we could potentially record this info as well and2132 * omit reporting rename/rename(1to2) conflicts for each path within2133 * the affected directories, thus cleaning up the merge output.2134 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the2135 * directory level, because merging directories is fine. If it2136 * causes conflicts for files within those merged directories, then2137 * that should be detected at the individual path level.2138 */2139static void handle_directory_level_conflicts(struct merge_options *o,2140 struct hashmap *dir_re_head,2141 struct tree *head,2142 struct hashmap *dir_re_merge,2143 struct tree *merge)2144{2145 struct hashmap_iter iter;2146 struct dir_rename_entry *head_ent;2147 struct dir_rename_entry *merge_ent;21482149 struct string_list remove_from_head = STRING_LIST_INIT_NODUP;2150 struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;21512152 hashmap_iter_init(dir_re_head, &iter);2153 while ((head_ent = hashmap_iter_next(&iter))) {2154 merge_ent = dir_rename_find_entry(dir_re_merge, head_ent->dir);2155 if (merge_ent &&2156 !head_ent->non_unique_new_dir &&2157 !merge_ent->non_unique_new_dir &&2158 !strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {2159 /* 1. Renamed identically; remove it from both sides */2160 string_list_append(&remove_from_head,2161 head_ent->dir)->util = head_ent;2162 strbuf_release(&head_ent->new_dir);2163 string_list_append(&remove_from_merge,2164 merge_ent->dir)->util = merge_ent;2165 strbuf_release(&merge_ent->new_dir);2166 } else if (tree_has_path(head, head_ent->dir)) {2167 /* 2. This wasn't a directory rename after all */2168 string_list_append(&remove_from_head,2169 head_ent->dir)->util = head_ent;2170 strbuf_release(&head_ent->new_dir);2171 }2172 }21732174 remove_hashmap_entries(dir_re_head, &remove_from_head);2175 remove_hashmap_entries(dir_re_merge, &remove_from_merge);21762177 hashmap_iter_init(dir_re_merge, &iter);2178 while ((merge_ent = hashmap_iter_next(&iter))) {2179 head_ent = dir_rename_find_entry(dir_re_head, merge_ent->dir);2180 if (tree_has_path(merge, merge_ent->dir)) {2181 /* 2. This wasn't a directory rename after all */2182 string_list_append(&remove_from_merge,2183 merge_ent->dir)->util = merge_ent;2184 } else if (head_ent &&2185 !head_ent->non_unique_new_dir &&2186 !merge_ent->non_unique_new_dir) {2187 /* 3. rename/rename(1to2) */2188 /*2189 * We can assume it's not rename/rename(1to1) because2190 * that was case (1), already checked above. So we2191 * know that head_ent->new_dir and merge_ent->new_dir2192 * are different strings.2193 */2194 output(o, 1, _("CONFLICT (rename/rename): "2195 "Rename directory %s->%s in %s. "2196 "Rename directory %s->%s in %s"),2197 head_ent->dir, head_ent->new_dir.buf, o->branch1,2198 head_ent->dir, merge_ent->new_dir.buf, o->branch2);2199 string_list_append(&remove_from_head,2200 head_ent->dir)->util = head_ent;2201 strbuf_release(&head_ent->new_dir);2202 string_list_append(&remove_from_merge,2203 merge_ent->dir)->util = merge_ent;2204 strbuf_release(&merge_ent->new_dir);2205 }2206 }22072208 remove_hashmap_entries(dir_re_head, &remove_from_head);2209 remove_hashmap_entries(dir_re_merge, &remove_from_merge);2210}22112212static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,2213 struct tree *tree)2214{2215 struct hashmap *dir_renames;2216 struct hashmap_iter iter;2217 struct dir_rename_entry *entry;2218 int i;22192220 /*2221 * Typically, we think of a directory rename as all files from a2222 * certain directory being moved to a target directory. However,2223 * what if someone first moved two files from the original2224 * directory in one commit, and then renamed the directory2225 * somewhere else in a later commit? At merge time, we just know2226 * that files from the original directory went to two different2227 * places, and that the bulk of them ended up in the same place.2228 * We want each directory rename to represent where the bulk of the2229 * files from that directory end up; this function exists to find2230 * where the bulk of the files went.2231 *2232 * The first loop below simply iterates through the list of file2233 * renames, finding out how often each directory rename pair2234 * possibility occurs.2235 */2236 dir_renames = xmalloc(sizeof(*dir_renames));2237 dir_rename_init(dir_renames);2238 for (i = 0; i < pairs->nr; ++i) {2239 struct string_list_item *item;2240 int *count;2241 struct diff_filepair *pair = pairs->queue[i];2242 char *old_dir, *new_dir;22432244 /* File not part of directory rename if it wasn't renamed */2245 if (pair->status != 'R')2246 continue;22472248 get_renamed_dir_portion(pair->one->path, pair->two->path,2249 &old_dir, &new_dir);2250 if (!old_dir)2251 /* Directory didn't change at all; ignore this one. */2252 continue;22532254 entry = dir_rename_find_entry(dir_renames, old_dir);2255 if (!entry) {2256 entry = xmalloc(sizeof(*entry));2257 dir_rename_entry_init(entry, old_dir);2258 hashmap_put(dir_renames, entry);2259 } else {2260 free(old_dir);2261 }2262 item = string_list_lookup(&entry->possible_new_dirs, new_dir);2263 if (!item) {2264 item = string_list_insert(&entry->possible_new_dirs,2265 new_dir);2266 item->util = xcalloc(1, sizeof(int));2267 } else {2268 free(new_dir);2269 }2270 count = item->util;2271 *count += 1;2272 }22732274 /*2275 * For each directory with files moved out of it, we find out which2276 * target directory received the most files so we can declare it to2277 * be the "winning" target location for the directory rename. This2278 * winner gets recorded in new_dir. If there is no winner2279 * (multiple target directories received the same number of files),2280 * we set non_unique_new_dir. Once we've determined the winner (or2281 * that there is no winner), we no longer need possible_new_dirs.2282 */2283 hashmap_iter_init(dir_renames, &iter);2284 while ((entry = hashmap_iter_next(&iter))) {2285 int max = 0;2286 int bad_max = 0;2287 char *best = NULL;22882289 for (i = 0; i < entry->possible_new_dirs.nr; i++) {2290 int *count = entry->possible_new_dirs.items[i].util;22912292 if (*count == max)2293 bad_max = max;2294 else if (*count > max) {2295 max = *count;2296 best = entry->possible_new_dirs.items[i].string;2297 }2298 }2299 if (bad_max == max)2300 entry->non_unique_new_dir = 1;2301 else {2302 assert(entry->new_dir.len == 0);2303 strbuf_addstr(&entry->new_dir, best);2304 }2305 /*2306 * The relevant directory sub-portion of the original full2307 * filepaths were xstrndup'ed before inserting into2308 * possible_new_dirs, and instead of manually iterating the2309 * list and free'ing each, just lie and tell2310 * possible_new_dirs that it did the strdup'ing so that it2311 * will free them for us.2312 */2313 entry->possible_new_dirs.strdup_strings = 1;2314 string_list_clear(&entry->possible_new_dirs, 1);2315 }23162317 return dir_renames;2318}23192320static struct dir_rename_entry *check_dir_renamed(const char *path,2321 struct hashmap *dir_renames)2322{2323 char *temp = xstrdup(path);2324 char *end;2325 struct dir_rename_entry *entry = NULL;23262327 while ((end = strrchr(temp, '/'))) {2328 *end = '\0';2329 entry = dir_rename_find_entry(dir_renames, temp);2330 if (entry)2331 break;2332 }2333 free(temp);2334 return entry;2335}23362337static void compute_collisions(struct hashmap *collisions,2338 struct hashmap *dir_renames,2339 struct diff_queue_struct *pairs)2340{2341 int i;23422343 /*2344 * Multiple files can be mapped to the same path due to directory2345 * renames done by the other side of history. Since that other2346 * side of history could have merged multiple directories into one,2347 * if our side of history added the same file basename to each of2348 * those directories, then all N of them would get implicitly2349 * renamed by the directory rename detection into the same path,2350 * and we'd get an add/add/.../add conflict, and all those adds2351 * from *this* side of history. This is not representable in the2352 * index, and users aren't going to easily be able to make sense of2353 * it. So we need to provide a good warning about what's2354 * happening, and fall back to no-directory-rename detection2355 * behavior for those paths.2356 *2357 * See testcases 9e and all of section 5 from t6043 for examples.2358 */2359 collision_init(collisions);23602361 for (i = 0; i < pairs->nr; ++i) {2362 struct dir_rename_entry *dir_rename_ent;2363 struct collision_entry *collision_ent;2364 char *new_path;2365 struct diff_filepair *pair = pairs->queue[i];23662367 if (pair->status != 'A' && pair->status != 'R')2368 continue;2369 dir_rename_ent = check_dir_renamed(pair->two->path,2370 dir_renames);2371 if (!dir_rename_ent)2372 continue;23732374 new_path = apply_dir_rename(dir_rename_ent, pair->two->path);2375 if (!new_path)2376 /*2377 * dir_rename_ent->non_unique_new_path is true, which2378 * means there is no directory rename for us to use,2379 * which means it won't cause us any additional2380 * collisions.2381 */2382 continue;2383 collision_ent = collision_find_entry(collisions, new_path);2384 if (!collision_ent) {2385 collision_ent = xcalloc(1,2386 sizeof(struct collision_entry));2387 hashmap_entry_init(collision_ent, strhash(new_path));2388 hashmap_put(collisions, collision_ent);2389 collision_ent->target_file = new_path;2390 } else {2391 free(new_path);2392 }2393 string_list_insert(&collision_ent->source_files,2394 pair->two->path);2395 }2396}23972398static char *check_for_directory_rename(struct merge_options *o,2399 const char *path,2400 struct tree *tree,2401 struct hashmap *dir_renames,2402 struct hashmap *dir_rename_exclusions,2403 struct hashmap *collisions,2404 int *clean_merge)2405{2406 char *new_path = NULL;2407 struct dir_rename_entry *entry = check_dir_renamed(path, dir_renames);2408 struct dir_rename_entry *oentry = NULL;24092410 if (!entry)2411 return new_path;24122413 /*2414 * This next part is a little weird. We do not want to do an2415 * implicit rename into a directory we renamed on our side, because2416 * that will result in a spurious rename/rename(1to2) conflict. An2417 * example:2418 * Base commit: dumbdir/afile, otherdir/bfile2419 * Side 1: smrtdir/afile, otherdir/bfile2420 * Side 2: dumbdir/afile, dumbdir/bfile2421 * Here, while working on Side 1, we could notice that otherdir was2422 * renamed/merged to dumbdir, and change the diff_filepair for2423 * otherdir/bfile into a rename into dumbdir/bfile. However, Side2424 * 2 will notice the rename from dumbdir to smrtdir, and do the2425 * transitive rename to move it from dumbdir/bfile to2426 * smrtdir/bfile. That gives us bfile in dumbdir vs being in2427 * smrtdir, a rename/rename(1to2) conflict. We really just want2428 * the file to end up in smrtdir. And the way to achieve that is2429 * to not let Side1 do the rename to dumbdir, since we know that is2430 * the source of one of our directory renames.2431 *2432 * That's why oentry and dir_rename_exclusions is here.2433 *2434 * As it turns out, this also prevents N-way transient rename2435 * confusion; See testcases 9c and 9d of t6043.2436 */2437 oentry = dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);2438 if (oentry) {2439 output(o, 1, _("WARNING: Avoiding applying %s -> %s rename "2440 "to %s, because %s itself was renamed."),2441 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);2442 } else {2443 new_path = handle_path_level_conflicts(o, path, entry,2444 collisions, tree);2445 *clean_merge &= (new_path != NULL);2446 }24472448 return new_path;2449}24502451static void apply_directory_rename_modifications(struct merge_options *o,2452 struct diff_filepair *pair,2453 char *new_path,2454 struct rename *re,2455 struct tree *tree,2456 struct tree *o_tree,2457 struct tree *a_tree,2458 struct tree *b_tree,2459 struct string_list *entries,2460 int *clean)2461{2462 struct string_list_item *item;2463 int stage = (tree == a_tree ? 2 : 3);2464 int update_wd;24652466 /*2467 * In all cases where we can do directory rename detection,2468 * unpack_trees() will have read pair->two->path into the2469 * index and the working copy. We need to remove it so that2470 * we can instead place it at new_path. It is guaranteed to2471 * not be untracked (unpack_trees() would have errored out2472 * saying the file would have been overwritten), but it might2473 * be dirty, though.2474 */2475 update_wd = !was_dirty(o, pair->two->path);2476 if (!update_wd)2477 output(o, 1, _("Refusing to lose dirty file at %s"),2478 pair->two->path);2479 remove_file(o, 1, pair->two->path, !update_wd);24802481 /* Find or create a new re->dst_entry */2482 item = string_list_lookup(entries, new_path);2483 if (item) {2484 /*2485 * Since we're renaming on this side of history, and it's2486 * due to a directory rename on the other side of history2487 * (which we only allow when the directory in question no2488 * longer exists on the other side of history), the2489 * original entry for re->dst_entry is no longer2490 * necessary...2491 */2492 re->dst_entry->processed = 1;24932494 /*2495 * ...because we'll be using this new one.2496 */2497 re->dst_entry = item->util;2498 } else {2499 /*2500 * re->dst_entry is for the before-dir-rename path, and we2501 * need it to hold information for the after-dir-rename2502 * path. Before creating a new entry, we need to mark the2503 * old one as unnecessary (...unless it is shared by2504 * src_entry, i.e. this didn't use to be a rename, in which2505 * case we can just allow the normal processing to happen2506 * for it).2507 */2508 if (pair->status == 'R')2509 re->dst_entry->processed = 1;25102511 re->dst_entry = insert_stage_data(new_path,2512 o_tree, a_tree, b_tree,2513 entries);2514 item = string_list_insert(entries, new_path);2515 item->util = re->dst_entry;2516 }25172518 /*2519 * Update the stage_data with the information about the path we are2520 * moving into place. That slot will be empty and available for us2521 * to write to because of the collision checks in2522 * handle_path_level_conflicts(). In other words,2523 * re->dst_entry->stages[stage].oid will be the null_oid, so it's2524 * open for us to write to.2525 *2526 * It may be tempting to actually update the index at this point as2527 * well, using update_stages_for_stage_data(), but as per the big2528 * "NOTE" in update_stages(), doing so will modify the current2529 * in-memory index which will break calls to would_lose_untracked()2530 * that we need to make. Instead, we need to just make sure that2531 * the various handle_rename_*() functions update the index2532 * explicitly rather than relying on unpack_trees() to have done it.2533 */2534 get_tree_entry(&tree->object.oid,2535 pair->two->path,2536 &re->dst_entry->stages[stage].oid,2537 &re->dst_entry->stages[stage].mode);25382539 /* Update pair status */2540 if (pair->status == 'A') {2541 /*2542 * Recording rename information for this add makes it look2543 * like a rename/delete conflict. Make sure we can2544 * correctly handle this as an add that was moved to a new2545 * directory instead of reporting a rename/delete conflict.2546 */2547 re->add_turned_into_rename = 1;2548 }2549 /*2550 * We don't actually look at pair->status again, but it seems2551 * pedagogically correct to adjust it.2552 */2553 pair->status = 'R';25542555 /*2556 * Finally, record the new location.2557 */2558 pair->two->path = new_path;2559}25602561/*2562 * Get information of all renames which occurred in 'pairs', making use of2563 * any implicit directory renames inferred from the other side of history.2564 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')2565 * to be able to associate the correct cache entries with the rename2566 * information; tree is always equal to either a_tree or b_tree.2567 */2568static struct string_list *get_renames(struct merge_options *o,2569 struct diff_queue_struct *pairs,2570 struct hashmap *dir_renames,2571 struct hashmap *dir_rename_exclusions,2572 struct tree *tree,2573 struct tree *o_tree,2574 struct tree *a_tree,2575 struct tree *b_tree,2576 struct string_list *entries,2577 int *clean_merge)2578{2579 int i;2580 struct hashmap collisions;2581 struct hashmap_iter iter;2582 struct collision_entry *e;2583 struct string_list *renames;25842585 compute_collisions(&collisions, dir_renames, pairs);2586 renames = xcalloc(1, sizeof(struct string_list));25872588 for (i = 0; i < pairs->nr; ++i) {2589 struct string_list_item *item;2590 struct rename *re;2591 struct diff_filepair *pair = pairs->queue[i];2592 char *new_path; /* non-NULL only with directory renames */25932594 if (pair->status != 'A' && pair->status != 'R') {2595 diff_free_filepair(pair);2596 continue;2597 }2598 new_path = check_for_directory_rename(o, pair->two->path, tree,2599 dir_renames,2600 dir_rename_exclusions,2601 &collisions,2602 clean_merge);2603 if (pair->status != 'R' && !new_path) {2604 diff_free_filepair(pair);2605 continue;2606 }26072608 re = xmalloc(sizeof(*re));2609 re->processed = 0;2610 re->add_turned_into_rename = 0;2611 re->pair = pair;2612 item = string_list_lookup(entries, re->pair->one->path);2613 if (!item)2614 re->src_entry = insert_stage_data(re->pair->one->path,2615 o_tree, a_tree, b_tree, entries);2616 else2617 re->src_entry = item->util;26182619 item = string_list_lookup(entries, re->pair->two->path);2620 if (!item)2621 re->dst_entry = insert_stage_data(re->pair->two->path,2622 o_tree, a_tree, b_tree, entries);2623 else2624 re->dst_entry = item->util;2625 item = string_list_insert(renames, pair->one->path);2626 item->util = re;2627 if (new_path)2628 apply_directory_rename_modifications(o, pair, new_path,2629 re, tree, o_tree,2630 a_tree, b_tree,2631 entries,2632 clean_merge);2633 }26342635 hashmap_iter_init(&collisions, &iter);2636 while ((e = hashmap_iter_next(&iter))) {2637 free(e->target_file);2638 string_list_clear(&e->source_files, 0);2639 }2640 hashmap_free(&collisions, 1);2641 return renames;2642}26432644static int process_renames(struct merge_options *o,2645 struct string_list *a_renames,2646 struct string_list *b_renames)2647{2648 int clean_merge = 1, i, j;2649 struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2650 struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2651 const struct rename *sre;26522653 for (i = 0; i < a_renames->nr; i++) {2654 sre = a_renames->items[i].util;2655 string_list_insert(&a_by_dst, sre->pair->two->path)->util2656 = (void *)sre;2657 }2658 for (i = 0; i < b_renames->nr; i++) {2659 sre = b_renames->items[i].util;2660 string_list_insert(&b_by_dst, sre->pair->two->path)->util2661 = (void *)sre;2662 }26632664 for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {2665 struct string_list *renames1, *renames2Dst;2666 struct rename *ren1 = NULL, *ren2 = NULL;2667 const char *branch1, *branch2;2668 const char *ren1_src, *ren1_dst;2669 struct string_list_item *lookup;26702671 if (i >= a_renames->nr) {2672 ren2 = b_renames->items[j++].util;2673 } else if (j >= b_renames->nr) {2674 ren1 = a_renames->items[i++].util;2675 } else {2676 int compare = strcmp(a_renames->items[i].string,2677 b_renames->items[j].string);2678 if (compare <= 0)2679 ren1 = a_renames->items[i++].util;2680 if (compare >= 0)2681 ren2 = b_renames->items[j++].util;2682 }26832684 /* TODO: refactor, so that 1/2 are not needed */2685 if (ren1) {2686 renames1 = a_renames;2687 renames2Dst = &b_by_dst;2688 branch1 = o->branch1;2689 branch2 = o->branch2;2690 } else {2691 renames1 = b_renames;2692 renames2Dst = &a_by_dst;2693 branch1 = o->branch2;2694 branch2 = o->branch1;2695 SWAP(ren2, ren1);2696 }26972698 if (ren1->processed)2699 continue;2700 ren1->processed = 1;2701 ren1->dst_entry->processed = 1;2702 /* BUG: We should only mark src_entry as processed if we2703 * are not dealing with a rename + add-source case.2704 */2705 ren1->src_entry->processed = 1;27062707 ren1_src = ren1->pair->one->path;2708 ren1_dst = ren1->pair->two->path;27092710 if (ren2) {2711 /* One file renamed on both sides */2712 const char *ren2_src = ren2->pair->one->path;2713 const char *ren2_dst = ren2->pair->two->path;2714 enum rename_type rename_type;2715 if (strcmp(ren1_src, ren2_src) != 0)2716 BUG("ren1_src != ren2_src");2717 ren2->dst_entry->processed = 1;2718 ren2->processed = 1;2719 if (strcmp(ren1_dst, ren2_dst) != 0) {2720 rename_type = RENAME_ONE_FILE_TO_TWO;2721 clean_merge = 0;2722 } else {2723 rename_type = RENAME_ONE_FILE_TO_ONE;2724 /* BUG: We should only remove ren1_src in2725 * the base stage (think of rename +2726 * add-source cases).2727 */2728 remove_file(o, 1, ren1_src, 1);2729 update_entry(ren1->dst_entry,2730 ren1->pair->one,2731 ren1->pair->two,2732 ren2->pair->two);2733 }2734 setup_rename_conflict_info(rename_type,2735 ren1->pair,2736 ren2->pair,2737 branch1,2738 branch2,2739 ren1->dst_entry,2740 ren2->dst_entry,2741 o,2742 NULL,2743 NULL);2744 } else if ((lookup = string_list_lookup(renames2Dst, ren1_dst))) {2745 /* Two different files renamed to the same thing */2746 char *ren2_dst;2747 ren2 = lookup->util;2748 ren2_dst = ren2->pair->two->path;2749 if (strcmp(ren1_dst, ren2_dst) != 0)2750 BUG("ren1_dst != ren2_dst");27512752 clean_merge = 0;2753 ren2->processed = 1;2754 /*2755 * BUG: We should only mark src_entry as processed2756 * if we are not dealing with a rename + add-source2757 * case.2758 */2759 ren2->src_entry->processed = 1;27602761 setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2762 ren1->pair,2763 ren2->pair,2764 branch1,2765 branch2,2766 ren1->dst_entry,2767 ren2->dst_entry,2768 o,2769 ren1->src_entry,2770 ren2->src_entry);27712772 } else {2773 /* Renamed in 1, maybe changed in 2 */2774 /* we only use sha1 and mode of these */2775 struct diff_filespec src_other, dst_other;2776 int try_merge;27772778 /*2779 * unpack_trees loads entries from common-commit2780 * into stage 1, from head-commit into stage 2, and2781 * from merge-commit into stage 3. We keep track2782 * of which side corresponds to the rename.2783 */2784 int renamed_stage = a_renames == renames1 ? 2 : 3;2785 int other_stage = a_renames == renames1 ? 3 : 2;27862787 /* BUG: We should only remove ren1_src in the base2788 * stage and in other_stage (think of rename +2789 * add-source case).2790 */2791 remove_file(o, 1, ren1_src,2792 renamed_stage == 2 || !was_tracked(o, ren1_src));27932794 oidcpy(&src_other.oid,2795 &ren1->src_entry->stages[other_stage].oid);2796 src_other.mode = ren1->src_entry->stages[other_stage].mode;2797 oidcpy(&dst_other.oid,2798 &ren1->dst_entry->stages[other_stage].oid);2799 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2800 try_merge = 0;28012802 if (oid_eq(&src_other.oid, &null_oid) &&2803 ren1->add_turned_into_rename) {2804 setup_rename_conflict_info(RENAME_VIA_DIR,2805 ren1->pair,2806 NULL,2807 branch1,2808 branch2,2809 ren1->dst_entry,2810 NULL,2811 o,2812 NULL,2813 NULL);2814 } else if (oid_eq(&src_other.oid, &null_oid)) {2815 setup_rename_conflict_info(RENAME_DELETE,2816 ren1->pair,2817 NULL,2818 branch1,2819 branch2,2820 ren1->dst_entry,2821 NULL,2822 o,2823 NULL,2824 NULL);2825 } else if ((dst_other.mode == ren1->pair->two->mode) &&2826 oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2827 /*2828 * Added file on the other side identical to2829 * the file being renamed: clean merge.2830 * Also, there is no need to overwrite the2831 * file already in the working copy, so call2832 * update_file_flags() instead of2833 * update_file().2834 */2835 if (update_file_flags(o,2836 &ren1->pair->two->oid,2837 ren1->pair->two->mode,2838 ren1_dst,2839 1, /* update_cache */2840 0 /* update_wd */))2841 clean_merge = -1;2842 } else if (!oid_eq(&dst_other.oid, &null_oid)) {2843 /*2844 * Probably not a clean merge, but it's2845 * premature to set clean_merge to 0 here,2846 * because if the rename merges cleanly and2847 * the merge exactly matches the newly added2848 * file, then the merge will be clean.2849 */2850 setup_rename_conflict_info(RENAME_ADD,2851 ren1->pair,2852 NULL,2853 branch1,2854 branch2,2855 ren1->dst_entry,2856 NULL,2857 o,2858 ren1->src_entry,2859 NULL);2860 } else2861 try_merge = 1;28622863 if (clean_merge < 0)2864 goto cleanup_and_return;2865 if (try_merge) {2866 struct diff_filespec *one, *a, *b;2867 src_other.path = (char *)ren1_src;28682869 one = ren1->pair->one;2870 if (a_renames == renames1) {2871 a = ren1->pair->two;2872 b = &src_other;2873 } else {2874 b = ren1->pair->two;2875 a = &src_other;2876 }2877 update_entry(ren1->dst_entry, one, a, b);2878 setup_rename_conflict_info(RENAME_NORMAL,2879 ren1->pair,2880 NULL,2881 branch1,2882 NULL,2883 ren1->dst_entry,2884 NULL,2885 o,2886 NULL,2887 NULL);2888 }2889 }2890 }2891cleanup_and_return:2892 string_list_clear(&a_by_dst, 0);2893 string_list_clear(&b_by_dst, 0);28942895 return clean_merge;2896}28972898struct rename_info {2899 struct string_list *head_renames;2900 struct string_list *merge_renames;2901};29022903static void initial_cleanup_rename(struct diff_queue_struct *pairs,2904 struct hashmap *dir_renames)2905{2906 struct hashmap_iter iter;2907 struct dir_rename_entry *e;29082909 hashmap_iter_init(dir_renames, &iter);2910 while ((e = hashmap_iter_next(&iter))) {2911 free(e->dir);2912 strbuf_release(&e->new_dir);2913 /* possible_new_dirs already cleared in get_directory_renames */2914 }2915 hashmap_free(dir_renames, 1);2916 free(dir_renames);29172918 free(pairs->queue);2919 free(pairs);2920}29212922static int detect_and_process_renames(struct merge_options *o,2923 struct tree *common,2924 struct tree *head,2925 struct tree *merge,2926 struct string_list *entries,2927 struct rename_info *ri)2928{2929 struct diff_queue_struct *head_pairs, *merge_pairs;2930 struct hashmap *dir_re_head, *dir_re_merge;2931 int clean = 1;29322933 ri->head_renames = NULL;2934 ri->merge_renames = NULL;29352936 if (!merge_detect_rename(o))2937 return 1;29382939 head_pairs = get_diffpairs(o, common, head);2940 merge_pairs = get_diffpairs(o, common, merge);29412942 if (o->detect_directory_renames) {2943 dir_re_head = get_directory_renames(head_pairs, head);2944 dir_re_merge = get_directory_renames(merge_pairs, merge);29452946 handle_directory_level_conflicts(o,2947 dir_re_head, head,2948 dir_re_merge, merge);2949 } else {2950 dir_re_head = xmalloc(sizeof(*dir_re_head));2951 dir_re_merge = xmalloc(sizeof(*dir_re_merge));2952 dir_rename_init(dir_re_head);2953 dir_rename_init(dir_re_merge);2954 }29552956 ri->head_renames = get_renames(o, head_pairs,2957 dir_re_merge, dir_re_head, head,2958 common, head, merge, entries,2959 &clean);2960 if (clean < 0)2961 goto cleanup;2962 ri->merge_renames = get_renames(o, merge_pairs,2963 dir_re_head, dir_re_merge, merge,2964 common, head, merge, entries,2965 &clean);2966 if (clean < 0)2967 goto cleanup;2968 clean &= process_renames(o, ri->head_renames, ri->merge_renames);29692970cleanup:2971 /*2972 * Some cleanup is deferred until cleanup_renames() because the2973 * data structures are still needed and referenced in2974 * process_entry(). But there are a few things we can free now.2975 */2976 initial_cleanup_rename(head_pairs, dir_re_head);2977 initial_cleanup_rename(merge_pairs, dir_re_merge);29782979 return clean;2980}29812982static void final_cleanup_rename(struct string_list *rename)2983{2984 const struct rename *re;2985 int i;29862987 if (rename == NULL)2988 return;29892990 for (i = 0; i < rename->nr; i++) {2991 re = rename->items[i].util;2992 diff_free_filepair(re->pair);2993 }2994 string_list_clear(rename, 1);2995 free(rename);2996}29972998static void final_cleanup_renames(struct rename_info *re_info)2999{3000 final_cleanup_rename(re_info->head_renames);3001 final_cleanup_rename(re_info->merge_renames);3002}30033004static struct object_id *stage_oid(const struct object_id *oid, unsigned mode)3005{3006 return (is_null_oid(oid) || mode == 0) ? NULL: (struct object_id *)oid;3007}30083009static int read_oid_strbuf(struct merge_options *o,3010 const struct object_id *oid,3011 struct strbuf *dst)3012{3013 void *buf;3014 enum object_type type;3015 unsigned long size;3016 buf = read_object_file(oid, &type, &size);3017 if (!buf)3018 return err(o, _("cannot read object %s"), oid_to_hex(oid));3019 if (type != OBJ_BLOB) {3020 free(buf);3021 return err(o, _("object %s is not a blob"), oid_to_hex(oid));3022 }3023 strbuf_attach(dst, buf, size, size + 1);3024 return 0;3025}30263027static int blob_unchanged(struct merge_options *opt,3028 const struct object_id *o_oid,3029 unsigned o_mode,3030 const struct object_id *a_oid,3031 unsigned a_mode,3032 int renormalize, const char *path)3033{3034 struct strbuf o = STRBUF_INIT;3035 struct strbuf a = STRBUF_INIT;3036 int ret = 0; /* assume changed for safety */30373038 if (a_mode != o_mode)3039 return 0;3040 if (oid_eq(o_oid, a_oid))3041 return 1;3042 if (!renormalize)3043 return 0;30443045 assert(o_oid && a_oid);3046 if (read_oid_strbuf(opt, o_oid, &o) || read_oid_strbuf(opt, a_oid, &a))3047 goto error_return;3048 /*3049 * Note: binary | is used so that both renormalizations are3050 * performed. Comparison can be skipped if both files are3051 * unchanged since their sha1s have already been compared.3052 */3053 if (renormalize_buffer(opt->repo->index, path, o.buf, o.len, &o) |3054 renormalize_buffer(opt->repo->index, path, a.buf, a.len, &a))3055 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));30563057error_return:3058 strbuf_release(&o);3059 strbuf_release(&a);3060 return ret;3061}30623063static int handle_modify_delete(struct merge_options *o,3064 const char *path,3065 struct object_id *o_oid, int o_mode,3066 struct object_id *a_oid, int a_mode,3067 struct object_id *b_oid, int b_mode)3068{3069 const char *modify_branch, *delete_branch;3070 struct object_id *changed_oid;3071 int changed_mode;30723073 if (a_oid) {3074 modify_branch = o->branch1;3075 delete_branch = o->branch2;3076 changed_oid = a_oid;3077 changed_mode = a_mode;3078 } else {3079 modify_branch = o->branch2;3080 delete_branch = o->branch1;3081 changed_oid = b_oid;3082 changed_mode = b_mode;3083 }30843085 return handle_change_delete(o,3086 path, NULL,3087 o_oid, o_mode,3088 changed_oid, changed_mode,3089 modify_branch, delete_branch,3090 _("modify"), _("modified"));3091}30923093static int handle_content_merge(struct merge_options *o,3094 const char *path,3095 int is_dirty,3096 struct object_id *o_oid, int o_mode,3097 struct object_id *a_oid, int a_mode,3098 struct object_id *b_oid, int b_mode,3099 struct rename_conflict_info *rename_conflict_info)3100{3101 const char *reason = _("content");3102 const char *path1 = NULL, *path2 = NULL;3103 struct merge_file_info mfi;3104 struct diff_filespec one, a, b;3105 unsigned df_conflict_remains = 0;31063107 if (!o_oid) {3108 reason = _("add/add");3109 o_oid = (struct object_id *)&null_oid;3110 }3111 one.path = a.path = b.path = (char *)path;3112 oidcpy(&one.oid, o_oid);3113 one.mode = o_mode;3114 oidcpy(&a.oid, a_oid);3115 a.mode = a_mode;3116 oidcpy(&b.oid, b_oid);3117 b.mode = b_mode;31183119 if (rename_conflict_info) {3120 struct diff_filepair *pair1 = rename_conflict_info->pair1;31213122 path1 = (o->branch1 == rename_conflict_info->branch1) ?3123 pair1->two->path : pair1->one->path;3124 /* If rename_conflict_info->pair2 != NULL, we are in3125 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a3126 * normal rename.3127 */3128 path2 = (rename_conflict_info->pair2 ||3129 o->branch2 == rename_conflict_info->branch1) ?3130 pair1->two->path : pair1->one->path;3131 one.path = pair1->one->path;3132 a.path = (char *)path1;3133 b.path = (char *)path2;31343135 if (dir_in_way(o->repo->index, path, !o->call_depth,3136 S_ISGITLINK(pair1->two->mode)))3137 df_conflict_remains = 1;3138 }3139 if (merge_mode_and_contents(o, &one, &a, &b, path,3140 o->branch1, o->branch2,3141 o->call_depth * 2, &mfi))3142 return -1;31433144 /*3145 * We can skip updating the working tree file iff:3146 * a) The merge is clean3147 * b) The merge matches what was in HEAD (content, mode, pathname)3148 * c) The target path is usable (i.e. not involved in D/F conflict)3149 */3150 if (mfi.clean &&3151 was_tracked_and_matches(o, path, &mfi.oid, mfi.mode) &&3152 !df_conflict_remains) {3153 int pos;3154 struct cache_entry *ce;31553156 output(o, 3, _("Skipped %s (merged same as existing)"), path);3157 if (add_cacheinfo(o, mfi.mode, &mfi.oid, path,3158 0, (!o->call_depth && !is_dirty), 0))3159 return -1;3160 /*3161 * However, add_cacheinfo() will delete the old cache entry3162 * and add a new one. We need to copy over any skip_worktree3163 * flag to avoid making the file appear as if it were3164 * deleted by the user.3165 */3166 pos = index_name_pos(&o->orig_index, path, strlen(path));3167 ce = o->orig_index.cache[pos];3168 if (ce_skip_worktree(ce)) {3169 pos = index_name_pos(o->repo->index, path, strlen(path));3170 ce = o->repo->index->cache[pos];3171 ce->ce_flags |= CE_SKIP_WORKTREE;3172 }3173 return mfi.clean;3174 }31753176 if (!mfi.clean) {3177 if (S_ISGITLINK(mfi.mode))3178 reason = _("submodule");3179 output(o, 1, _("CONFLICT (%s): Merge conflict in %s"),3180 reason, path);3181 if (rename_conflict_info && !df_conflict_remains)3182 if (update_stages(o, path, &one, &a, &b))3183 return -1;3184 }31853186 if (df_conflict_remains || is_dirty) {3187 char *new_path;3188 if (o->call_depth) {3189 remove_file_from_index(o->repo->index, path);3190 } else {3191 if (!mfi.clean) {3192 if (update_stages(o, path, &one, &a, &b))3193 return -1;3194 } else {3195 int file_from_stage2 = was_tracked(o, path);3196 struct diff_filespec merged;3197 oidcpy(&merged.oid, &mfi.oid);3198 merged.mode = mfi.mode;31993200 if (update_stages(o, path, NULL,3201 file_from_stage2 ? &merged : NULL,3202 file_from_stage2 ? NULL : &merged))3203 return -1;3204 }32053206 }3207 new_path = unique_path(o, path, rename_conflict_info->branch1);3208 if (is_dirty) {3209 output(o, 1, _("Refusing to lose dirty file at %s"),3210 path);3211 }3212 output(o, 1, _("Adding as %s instead"), new_path);3213 if (update_file(o, 0, &mfi.oid, mfi.mode, new_path)) {3214 free(new_path);3215 return -1;3216 }3217 free(new_path);3218 mfi.clean = 0;3219 } else if (update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))3220 return -1;3221 return !is_dirty && mfi.clean;3222}32233224static int handle_rename_normal(struct merge_options *o,3225 const char *path,3226 struct object_id *o_oid, unsigned int o_mode,3227 struct object_id *a_oid, unsigned int a_mode,3228 struct object_id *b_oid, unsigned int b_mode,3229 struct rename_conflict_info *ci)3230{3231 /* Merge the content and write it out */3232 return handle_content_merge(o, path, was_dirty(o, path),3233 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3234 ci);3235}32363237/* Per entry merge function */3238static int process_entry(struct merge_options *o,3239 const char *path, struct stage_data *entry)3240{3241 int clean_merge = 1;3242 int normalize = o->renormalize;3243 unsigned o_mode = entry->stages[1].mode;3244 unsigned a_mode = entry->stages[2].mode;3245 unsigned b_mode = entry->stages[3].mode;3246 struct object_id *o_oid = stage_oid(&entry->stages[1].oid, o_mode);3247 struct object_id *a_oid = stage_oid(&entry->stages[2].oid, a_mode);3248 struct object_id *b_oid = stage_oid(&entry->stages[3].oid, b_mode);32493250 entry->processed = 1;3251 if (entry->rename_conflict_info) {3252 struct rename_conflict_info *conflict_info = entry->rename_conflict_info;3253 switch (conflict_info->rename_type) {3254 case RENAME_NORMAL:3255 case RENAME_ONE_FILE_TO_ONE:3256 clean_merge = handle_rename_normal(o,3257 path,3258 o_oid, o_mode,3259 a_oid, a_mode,3260 b_oid, b_mode,3261 conflict_info);3262 break;3263 case RENAME_VIA_DIR:3264 clean_merge = 1;3265 if (handle_rename_via_dir(o,3266 conflict_info->pair1,3267 conflict_info->branch1,3268 conflict_info->branch2))3269 clean_merge = -1;3270 break;3271 case RENAME_ADD:3272 /*3273 * Probably unclean merge, but if the renamed file3274 * merges cleanly and the result can then be3275 * two-way merged cleanly with the added file, I3276 * guess it's a clean merge?3277 */3278 clean_merge = handle_rename_add(o, conflict_info);3279 break;3280 case RENAME_DELETE:3281 clean_merge = 0;3282 if (handle_rename_delete(o,3283 conflict_info->pair1,3284 conflict_info->branch1,3285 conflict_info->branch2))3286 clean_merge = -1;3287 break;3288 case RENAME_ONE_FILE_TO_TWO:3289 clean_merge = 0;3290 if (handle_rename_rename_1to2(o, conflict_info))3291 clean_merge = -1;3292 break;3293 case RENAME_TWO_FILES_TO_ONE:3294 /*3295 * Probably unclean merge, but if the two renamed3296 * files merge cleanly and the two resulting files3297 * can then be two-way merged cleanly, I guess it's3298 * a clean merge?3299 */3300 clean_merge = handle_rename_rename_2to1(o,3301 conflict_info);3302 break;3303 default:3304 entry->processed = 0;3305 break;3306 }3307 } else if (o_oid && (!a_oid || !b_oid)) {3308 /* Case A: Deleted in one */3309 if ((!a_oid && !b_oid) ||3310 (!b_oid && blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||3311 (!a_oid && blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {3312 /* Deleted in both or deleted in one and3313 * unchanged in the other */3314 if (a_oid)3315 output(o, 2, _("Removing %s"), path);3316 /* do not touch working file if it did not exist */3317 remove_file(o, 1, path, !a_oid);3318 } else {3319 /* Modify/delete; deleted side may have put a directory in the way */3320 clean_merge = 0;3321 if (handle_modify_delete(o, path, o_oid, o_mode,3322 a_oid, a_mode, b_oid, b_mode))3323 clean_merge = -1;3324 }3325 } else if ((!o_oid && a_oid && !b_oid) ||3326 (!o_oid && !a_oid && b_oid)) {3327 /* Case B: Added in one. */3328 /* [nothing|directory] -> ([nothing|directory], file) */33293330 const char *add_branch;3331 const char *other_branch;3332 unsigned mode;3333 const struct object_id *oid;3334 const char *conf;33353336 if (a_oid) {3337 add_branch = o->branch1;3338 other_branch = o->branch2;3339 mode = a_mode;3340 oid = a_oid;3341 conf = _("file/directory");3342 } else {3343 add_branch = o->branch2;3344 other_branch = o->branch1;3345 mode = b_mode;3346 oid = b_oid;3347 conf = _("directory/file");3348 }3349 if (dir_in_way(o->repo->index, path,3350 !o->call_depth && !S_ISGITLINK(a_mode),3351 0)) {3352 char *new_path = unique_path(o, path, add_branch);3353 clean_merge = 0;3354 output(o, 1, _("CONFLICT (%s): There is a directory with name %s in %s. "3355 "Adding %s as %s"),3356 conf, path, other_branch, path, new_path);3357 if (update_file(o, 0, oid, mode, new_path))3358 clean_merge = -1;3359 else if (o->call_depth)3360 remove_file_from_index(o->repo->index, path);3361 free(new_path);3362 } else {3363 output(o, 2, _("Adding %s"), path);3364 /* do not overwrite file if already present */3365 if (update_file_flags(o, oid, mode, path, 1, !a_oid))3366 clean_merge = -1;3367 }3368 } else if (a_oid && b_oid) {3369 if (!o_oid) {3370 /* Case C: Added in both (check for same permissions) */3371 output(o, 1,3372 _("CONFLICT (add/add): Merge conflict in %s"),3373 path);3374 clean_merge = handle_file_collision(o,3375 path, NULL, NULL,3376 o->branch1,3377 o->branch2,3378 a_oid, a_mode,3379 b_oid, b_mode);3380 } else {3381 /* case D: Modified in both, but differently. */3382 int is_dirty = 0; /* unpack_trees would have bailed if dirty */3383 clean_merge = handle_content_merge(o, path,3384 is_dirty,3385 o_oid, o_mode,3386 a_oid, a_mode,3387 b_oid, b_mode,3388 NULL);3389 }3390 } else if (!o_oid && !a_oid && !b_oid) {3391 /*3392 * this entry was deleted altogether. a_mode == 0 means3393 * we had that path and want to actively remove it.3394 */3395 remove_file(o, 1, path, !a_mode);3396 } else3397 BUG("fatal merge failure, shouldn't happen.");33983399 return clean_merge;3400}34013402int merge_trees(struct merge_options *o,3403 struct tree *head,3404 struct tree *merge,3405 struct tree *common,3406 struct tree **result)3407{3408 struct index_state *istate = o->repo->index;3409 int code, clean;3410 struct strbuf sb = STRBUF_INIT;34113412 if (!o->call_depth && index_has_changes(istate, head, &sb)) {3413 err(o, _("Your local changes to the following files would be overwritten by merge:\n %s"),3414 sb.buf);3415 return -1;3416 }34173418 if (o->subtree_shift) {3419 merge = shift_tree_object(head, merge, o->subtree_shift);3420 common = shift_tree_object(head, common, o->subtree_shift);3421 }34223423 if (oid_eq(&common->object.oid, &merge->object.oid)) {3424 output(o, 0, _("Already up to date!"));3425 *result = head;3426 return 1;3427 }34283429 code = unpack_trees_start(o, common, head, merge);34303431 if (code != 0) {3432 if (show(o, 4) || o->call_depth)3433 err(o, _("merging of trees %s and %s failed"),3434 oid_to_hex(&head->object.oid),3435 oid_to_hex(&merge->object.oid));3436 unpack_trees_finish(o);3437 return -1;3438 }34393440 if (unmerged_index(istate)) {3441 struct string_list *entries;3442 struct rename_info re_info;3443 int i;3444 /*3445 * Only need the hashmap while processing entries, so3446 * initialize it here and free it when we are done running3447 * through the entries. Keeping it in the merge_options as3448 * opposed to decaring a local hashmap is for convenience3449 * so that we don't have to pass it to around.3450 */3451 hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL, 512);3452 get_files_dirs(o, head);3453 get_files_dirs(o, merge);34543455 entries = get_unmerged(o->repo->index);3456 clean = detect_and_process_renames(o, common, head, merge,3457 entries, &re_info);3458 record_df_conflict_files(o, entries);3459 if (clean < 0)3460 goto cleanup;3461 for (i = entries->nr-1; 0 <= i; i--) {3462 const char *path = entries->items[i].string;3463 struct stage_data *e = entries->items[i].util;3464 if (!e->processed) {3465 int ret = process_entry(o, path, e);3466 if (!ret)3467 clean = 0;3468 else if (ret < 0) {3469 clean = ret;3470 goto cleanup;3471 }3472 }3473 }3474 for (i = 0; i < entries->nr; i++) {3475 struct stage_data *e = entries->items[i].util;3476 if (!e->processed)3477 BUG("unprocessed path??? %s",3478 entries->items[i].string);3479 }34803481 cleanup:3482 final_cleanup_renames(&re_info);34833484 string_list_clear(entries, 1);3485 free(entries);34863487 hashmap_free(&o->current_file_dir_set, 1);34883489 if (clean < 0) {3490 unpack_trees_finish(o);3491 return clean;3492 }3493 }3494 else3495 clean = 1;34963497 unpack_trees_finish(o);34983499 if (o->call_depth && !(*result = write_tree_from_memory(o)))3500 return -1;35013502 return clean;3503}35043505static struct commit_list *reverse_commit_list(struct commit_list *list)3506{3507 struct commit_list *next = NULL, *current, *backup;3508 for (current = list; current; current = backup) {3509 backup = current->next;3510 current->next = next;3511 next = current;3512 }3513 return next;3514}35153516/*3517 * Merge the commits h1 and h2, return the resulting virtual3518 * commit object and a flag indicating the cleanness of the merge.3519 */3520int merge_recursive(struct merge_options *o,3521 struct commit *h1,3522 struct commit *h2,3523 struct commit_list *ca,3524 struct commit **result)3525{3526 struct commit_list *iter;3527 struct commit *merged_common_ancestors;3528 struct tree *mrtree;3529 int clean;35303531 if (show(o, 4)) {3532 output(o, 4, _("Merging:"));3533 output_commit_title(o, h1);3534 output_commit_title(o, h2);3535 }35363537 if (!ca) {3538 ca = get_merge_bases(h1, h2);3539 ca = reverse_commit_list(ca);3540 }35413542 if (show(o, 5)) {3543 unsigned cnt = commit_list_count(ca);35443545 output(o, 5, Q_("found %u common ancestor:",3546 "found %u common ancestors:", cnt), cnt);3547 for (iter = ca; iter; iter = iter->next)3548 output_commit_title(o, iter->item);3549 }35503551 merged_common_ancestors = pop_commit(&ca);3552 if (merged_common_ancestors == NULL) {3553 /* if there is no common ancestor, use an empty tree */3554 struct tree *tree;35553556 tree = lookup_tree(the_repository, the_repository->hash_algo->empty_tree);3557 merged_common_ancestors = make_virtual_commit(tree, "ancestor");3558 }35593560 for (iter = ca; iter; iter = iter->next) {3561 const char *saved_b1, *saved_b2;3562 o->call_depth++;3563 /*3564 * When the merge fails, the result contains files3565 * with conflict markers. The cleanness flag is3566 * ignored (unless indicating an error), it was never3567 * actually used, as result of merge_trees has always3568 * overwritten it: the committed "conflicts" were3569 * already resolved.3570 */3571 discard_index(o->repo->index);3572 saved_b1 = o->branch1;3573 saved_b2 = o->branch2;3574 o->branch1 = "Temporary merge branch 1";3575 o->branch2 = "Temporary merge branch 2";3576 if (merge_recursive(o, merged_common_ancestors, iter->item,3577 NULL, &merged_common_ancestors) < 0)3578 return -1;3579 o->branch1 = saved_b1;3580 o->branch2 = saved_b2;3581 o->call_depth--;35823583 if (!merged_common_ancestors)3584 return err(o, _("merge returned no commit"));3585 }35863587 discard_index(o->repo->index);3588 if (!o->call_depth)3589 repo_read_index(o->repo);35903591 o->ancestor = "merged common ancestors";3592 clean = merge_trees(o, get_commit_tree(h1), get_commit_tree(h2),3593 get_commit_tree(merged_common_ancestors),3594 &mrtree);3595 if (clean < 0) {3596 flush_output(o);3597 return clean;3598 }35993600 if (o->call_depth) {3601 *result = make_virtual_commit(mrtree, "merged tree");3602 commit_list_insert(h1, &(*result)->parents);3603 commit_list_insert(h2, &(*result)->parents->next);3604 }3605 flush_output(o);3606 if (!o->call_depth && o->buffer_output < 2)3607 strbuf_release(&o->obuf);3608 if (show(o, 2))3609 diff_warn_rename_limit("merge.renamelimit",3610 o->needed_rename_limit, 0);3611 return clean;3612}36133614static struct commit *get_ref(const struct object_id *oid, const char *name)3615{3616 struct object *object;36173618 object = deref_tag(the_repository, parse_object(the_repository, oid),3619 name,3620 strlen(name));3621 if (!object)3622 return NULL;3623 if (object->type == OBJ_TREE)3624 return make_virtual_commit((struct tree*)object, name);3625 if (object->type != OBJ_COMMIT)3626 return NULL;3627 if (parse_commit((struct commit *)object))3628 return NULL;3629 return (struct commit *)object;3630}36313632int merge_recursive_generic(struct merge_options *o,3633 const struct object_id *head,3634 const struct object_id *merge,3635 int num_base_list,3636 const struct object_id **base_list,3637 struct commit **result)3638{3639 int clean;3640 struct lock_file lock = LOCK_INIT;3641 struct commit *head_commit = get_ref(head, o->branch1);3642 struct commit *next_commit = get_ref(merge, o->branch2);3643 struct commit_list *ca = NULL;36443645 if (base_list) {3646 int i;3647 for (i = 0; i < num_base_list; ++i) {3648 struct commit *base;3649 if (!(base = get_ref(base_list[i], oid_to_hex(base_list[i]))))3650 return err(o, _("Could not parse object '%s'"),3651 oid_to_hex(base_list[i]));3652 commit_list_insert(base, &ca);3653 }3654 }36553656 repo_hold_locked_index(o->repo, &lock, LOCK_DIE_ON_ERROR);3657 clean = merge_recursive(o, head_commit, next_commit, ca,3658 result);3659 if (clean < 0) {3660 rollback_lock_file(&lock);3661 return clean;3662 }36633664 if (write_locked_index(o->repo->index, &lock,3665 COMMIT_LOCK | SKIP_IF_UNCHANGED))3666 return err(o, _("Unable to write index."));36673668 return clean ? 0 : 1;3669}36703671static void merge_recursive_config(struct merge_options *o)3672{3673 char *value = NULL;3674 git_config_get_int("merge.verbosity", &o->verbosity);3675 git_config_get_int("diff.renamelimit", &o->diff_rename_limit);3676 git_config_get_int("merge.renamelimit", &o->merge_rename_limit);3677 if (!git_config_get_string("diff.renames", &value)) {3678 o->diff_detect_rename = git_config_rename("diff.renames", value);3679 free(value);3680 }3681 if (!git_config_get_string("merge.renames", &value)) {3682 o->merge_detect_rename = git_config_rename("merge.renames", value);3683 free(value);3684 }3685 git_config(git_xmerge_config, NULL);3686}36873688void init_merge_options(struct merge_options *o,3689 struct repository *repo)3690{3691 const char *merge_verbosity;3692 memset(o, 0, sizeof(struct merge_options));3693 o->repo = repo;3694 o->verbosity = 2;3695 o->buffer_output = 1;3696 o->diff_rename_limit = -1;3697 o->merge_rename_limit = -1;3698 o->renormalize = 0;3699 o->diff_detect_rename = -1;3700 o->merge_detect_rename = -1;3701 o->detect_directory_renames = 1;3702 merge_recursive_config(o);3703 merge_verbosity = getenv("GIT_MERGE_VERBOSITY");3704 if (merge_verbosity)3705 o->verbosity = strtol(merge_verbosity, NULL, 10);3706 if (o->verbosity >= 5)3707 o->buffer_output = 0;3708 strbuf_init(&o->obuf, 0);3709 string_list_init(&o->df_conflict_file_set, 1);3710}37113712int parse_merge_opt(struct merge_options *o, const char *s)3713{3714 const char *arg;37153716 if (!s || !*s)3717 return -1;3718 if (!strcmp(s, "ours"))3719 o->recursive_variant = MERGE_RECURSIVE_OURS;3720 else if (!strcmp(s, "theirs"))3721 o->recursive_variant = MERGE_RECURSIVE_THEIRS;3722 else if (!strcmp(s, "subtree"))3723 o->subtree_shift = "";3724 else if (skip_prefix(s, "subtree=", &arg))3725 o->subtree_shift = arg;3726 else if (!strcmp(s, "patience"))3727 o->xdl_opts = DIFF_WITH_ALG(o, PATIENCE_DIFF);3728 else if (!strcmp(s, "histogram"))3729 o->xdl_opts = DIFF_WITH_ALG(o, HISTOGRAM_DIFF);3730 else if (skip_prefix(s, "diff-algorithm=", &arg)) {3731 long value = parse_algorithm_value(arg);3732 if (value < 0)3733 return -1;3734 /* clear out previous settings */3735 DIFF_XDL_CLR(o, NEED_MINIMAL);3736 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3737 o->xdl_opts |= value;3738 }3739 else if (!strcmp(s, "ignore-space-change"))3740 DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);3741 else if (!strcmp(s, "ignore-all-space"))3742 DIFF_XDL_SET(o, IGNORE_WHITESPACE);3743 else if (!strcmp(s, "ignore-space-at-eol"))3744 DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);3745 else if (!strcmp(s, "ignore-cr-at-eol"))3746 DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);3747 else if (!strcmp(s, "renormalize"))3748 o->renormalize = 1;3749 else if (!strcmp(s, "no-renormalize"))3750 o->renormalize = 0;3751 else if (!strcmp(s, "no-renames"))3752 o->merge_detect_rename = 0;3753 else if (!strcmp(s, "find-renames")) {3754 o->merge_detect_rename = 1;3755 o->rename_score = 0;3756 }3757 else if (skip_prefix(s, "find-renames=", &arg) ||3758 skip_prefix(s, "rename-threshold=", &arg)) {3759 if ((o->rename_score = parse_rename_score(&arg)) == -1 || *arg != 0)3760 return -1;3761 o->merge_detect_rename = 1;3762 }3763 else3764 return -1;3765 return 0;3766}