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"commit.h" 13#include"blob.h" 14#include"builtin.h" 15#include"tree-walk.h" 16#include"diff.h" 17#include"diffcore.h" 18#include"tag.h" 19#include"alloc.h" 20#include"unpack-trees.h" 21#include"string-list.h" 22#include"xdiff-interface.h" 23#include"ll-merge.h" 24#include"attr.h" 25#include"merge-recursive.h" 26#include"dir.h" 27#include"submodule.h" 28#include"revision.h" 29 30struct path_hashmap_entry { 31struct hashmap_entry e; 32char path[FLEX_ARRAY]; 33}; 34 35static intpath_hashmap_cmp(const void*cmp_data, 36const void*entry, 37const void*entry_or_key, 38const void*keydata) 39{ 40const struct path_hashmap_entry *a = entry; 41const struct path_hashmap_entry *b = entry_or_key; 42const char*key = keydata; 43 44if(ignore_case) 45returnstrcasecmp(a->path, key ? key : b->path); 46else 47returnstrcmp(a->path, key ? key : b->path); 48} 49 50static unsigned intpath_hash(const char*path) 51{ 52return ignore_case ?strihash(path) :strhash(path); 53} 54 55static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap, 56char*dir) 57{ 58struct dir_rename_entry key; 59 60if(dir == NULL) 61return NULL; 62hashmap_entry_init(&key,strhash(dir)); 63 key.dir = dir; 64returnhashmap_get(hashmap, &key, NULL); 65} 66 67static intdir_rename_cmp(const void*unused_cmp_data, 68const void*entry, 69const void*entry_or_key, 70const void*unused_keydata) 71{ 72const struct dir_rename_entry *e1 = entry; 73const struct dir_rename_entry *e2 = entry_or_key; 74 75returnstrcmp(e1->dir, e2->dir); 76} 77 78static voiddir_rename_init(struct hashmap *map) 79{ 80hashmap_init(map, dir_rename_cmp, NULL,0); 81} 82 83static voiddir_rename_entry_init(struct dir_rename_entry *entry, 84char*directory) 85{ 86hashmap_entry_init(entry,strhash(directory)); 87 entry->dir = directory; 88 entry->non_unique_new_dir =0; 89strbuf_init(&entry->new_dir,0); 90string_list_init(&entry->possible_new_dirs,0); 91} 92 93static struct collision_entry *collision_find_entry(struct hashmap *hashmap, 94char*target_file) 95{ 96struct collision_entry key; 97 98hashmap_entry_init(&key,strhash(target_file)); 99 key.target_file = target_file; 100returnhashmap_get(hashmap, &key, NULL); 101} 102 103static intcollision_cmp(void*unused_cmp_data, 104const struct collision_entry *e1, 105const struct collision_entry *e2, 106const void*unused_keydata) 107{ 108returnstrcmp(e1->target_file, e2->target_file); 109} 110 111static voidcollision_init(struct hashmap *map) 112{ 113hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL,0); 114} 115 116static voidflush_output(struct merge_options *o) 117{ 118if(o->buffer_output <2&& o->obuf.len) { 119fputs(o->obuf.buf, stdout); 120strbuf_reset(&o->obuf); 121} 122} 123 124static interr(struct merge_options *o,const char*err, ...) 125{ 126va_list params; 127 128if(o->buffer_output <2) 129flush_output(o); 130else{ 131strbuf_complete(&o->obuf,'\n'); 132strbuf_addstr(&o->obuf,"error: "); 133} 134va_start(params, err); 135strbuf_vaddf(&o->obuf, err, params); 136va_end(params); 137if(o->buffer_output >1) 138strbuf_addch(&o->obuf,'\n'); 139else{ 140error("%s", o->obuf.buf); 141strbuf_reset(&o->obuf); 142} 143 144return-1; 145} 146 147static struct tree *shift_tree_object(struct tree *one,struct tree *two, 148const char*subtree_shift) 149{ 150struct object_id shifted; 151 152if(!*subtree_shift) { 153shift_tree(&one->object.oid, &two->object.oid, &shifted,0); 154}else{ 155shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 156 subtree_shift); 157} 158if(!oidcmp(&two->object.oid, &shifted)) 159return two; 160returnlookup_tree(&shifted); 161} 162 163static struct commit *make_virtual_commit(struct tree *tree,const char*comment) 164{ 165struct commit *commit =alloc_commit_node(the_repository); 166 167set_merge_remote_desc(commit, comment, (struct object *)commit); 168 commit->maybe_tree = tree; 169 commit->object.parsed =1; 170return commit; 171} 172 173/* 174 * Since we use get_tree_entry(), which does not put the read object into 175 * the object pool, we cannot rely on a == b. 176 */ 177static intoid_eq(const struct object_id *a,const struct object_id *b) 178{ 179if(!a && !b) 180return2; 181return a && b &&oidcmp(a, b) ==0; 182} 183 184enum rename_type { 185 RENAME_NORMAL =0, 186 RENAME_DIR, 187 RENAME_DELETE, 188 RENAME_ONE_FILE_TO_ONE, 189 RENAME_ONE_FILE_TO_TWO, 190 RENAME_TWO_FILES_TO_ONE 191}; 192 193struct rename_conflict_info { 194enum rename_type rename_type; 195struct diff_filepair *pair1; 196struct diff_filepair *pair2; 197const char*branch1; 198const char*branch2; 199struct stage_data *dst_entry1; 200struct stage_data *dst_entry2; 201struct diff_filespec ren1_other; 202struct diff_filespec ren2_other; 203}; 204 205/* 206 * Since we want to write the index eventually, we cannot reuse the index 207 * for these (temporary) data. 208 */ 209struct stage_data { 210struct{ 211unsigned mode; 212struct object_id oid; 213} stages[4]; 214struct rename_conflict_info *rename_conflict_info; 215unsigned processed:1; 216}; 217 218staticinlinevoidsetup_rename_conflict_info(enum rename_type rename_type, 219struct diff_filepair *pair1, 220struct diff_filepair *pair2, 221const char*branch1, 222const char*branch2, 223struct stage_data *dst_entry1, 224struct stage_data *dst_entry2, 225struct merge_options *o, 226struct stage_data *src_entry1, 227struct stage_data *src_entry2) 228{ 229struct rename_conflict_info *ci =xcalloc(1,sizeof(struct rename_conflict_info)); 230 ci->rename_type = rename_type; 231 ci->pair1 = pair1; 232 ci->branch1 = branch1; 233 ci->branch2 = branch2; 234 235 ci->dst_entry1 = dst_entry1; 236 dst_entry1->rename_conflict_info = ci; 237 dst_entry1->processed =0; 238 239assert(!pair2 == !dst_entry2); 240if(dst_entry2) { 241 ci->dst_entry2 = dst_entry2; 242 ci->pair2 = pair2; 243 dst_entry2->rename_conflict_info = ci; 244} 245 246if(rename_type == RENAME_TWO_FILES_TO_ONE) { 247/* 248 * For each rename, there could have been 249 * modifications on the side of history where that 250 * file was not renamed. 251 */ 252int ostage1 = o->branch1 == branch1 ?3:2; 253int ostage2 = ostage1 ^1; 254 255 ci->ren1_other.path = pair1->one->path; 256oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid); 257 ci->ren1_other.mode = src_entry1->stages[ostage1].mode; 258 259 ci->ren2_other.path = pair2->one->path; 260oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid); 261 ci->ren2_other.mode = src_entry2->stages[ostage2].mode; 262} 263} 264 265static intshow(struct merge_options *o,int v) 266{ 267return(!o->call_depth && o->verbosity >= v) || o->verbosity >=5; 268} 269 270__attribute__((format(printf,3,4))) 271static voidoutput(struct merge_options *o,int v,const char*fmt, ...) 272{ 273va_list ap; 274 275if(!show(o, v)) 276return; 277 278strbuf_addchars(&o->obuf,' ', o->call_depth *2); 279 280va_start(ap, fmt); 281strbuf_vaddf(&o->obuf, fmt, ap); 282va_end(ap); 283 284strbuf_addch(&o->obuf,'\n'); 285if(!o->buffer_output) 286flush_output(o); 287} 288 289static voidoutput_commit_title(struct merge_options *o,struct commit *commit) 290{ 291struct merge_remote_desc *desc; 292 293strbuf_addchars(&o->obuf,' ', o->call_depth *2); 294 desc =merge_remote_util(commit); 295if(desc) 296strbuf_addf(&o->obuf,"virtual%s\n", desc->name); 297else{ 298strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid, 299 DEFAULT_ABBREV); 300strbuf_addch(&o->obuf,' '); 301if(parse_commit(commit) !=0) 302strbuf_addstr(&o->obuf,_("(bad commit)\n")); 303else{ 304const char*title; 305const char*msg =get_commit_buffer(commit, NULL); 306int len =find_commit_subject(msg, &title); 307if(len) 308strbuf_addf(&o->obuf,"%.*s\n", len, title); 309unuse_commit_buffer(commit, msg); 310} 311} 312flush_output(o); 313} 314 315static intadd_cacheinfo(struct merge_options *o, 316unsigned int mode,const struct object_id *oid, 317const char*path,int stage,int refresh,int options) 318{ 319struct cache_entry *ce; 320int ret; 321 322 ce =make_cache_entry(mode, oid ? oid->hash : null_sha1, path, stage,0); 323if(!ce) 324returnerr(o,_("add_cacheinfo failed for path '%s'; merge aborting."), path); 325 326 ret =add_cache_entry(ce, options); 327if(refresh) { 328struct cache_entry *nce; 329 330 nce =refresh_cache_entry(ce, CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 331if(!nce) 332returnerr(o,_("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); 333if(nce != ce) 334 ret =add_cache_entry(nce, options); 335} 336return ret; 337} 338 339static voidinit_tree_desc_from_tree(struct tree_desc *desc,struct tree *tree) 340{ 341parse_tree(tree); 342init_tree_desc(desc, tree->buffer, tree->size); 343} 344 345static intunpack_trees_start(struct merge_options *o, 346struct tree *common, 347struct tree *head, 348struct tree *merge) 349{ 350int rc; 351struct tree_desc t[3]; 352struct index_state tmp_index = { NULL }; 353 354memset(&o->unpack_opts,0,sizeof(o->unpack_opts)); 355if(o->call_depth) 356 o->unpack_opts.index_only =1; 357else 358 o->unpack_opts.update =1; 359 o->unpack_opts.merge =1; 360 o->unpack_opts.head_idx =2; 361 o->unpack_opts.fn = threeway_merge; 362 o->unpack_opts.src_index = &the_index; 363 o->unpack_opts.dst_index = &tmp_index; 364 o->unpack_opts.aggressive = !merge_detect_rename(o); 365setup_unpack_trees_porcelain(&o->unpack_opts,"merge"); 366 367init_tree_desc_from_tree(t+0, common); 368init_tree_desc_from_tree(t+1, head); 369init_tree_desc_from_tree(t+2, merge); 370 371 rc =unpack_trees(3, t, &o->unpack_opts); 372cache_tree_free(&active_cache_tree); 373 374/* 375 * Update the_index to match the new results, AFTER saving a copy 376 * in o->orig_index. Update src_index to point to the saved copy. 377 * (verify_uptodate() checks src_index, and the original index is 378 * the one that had the necessary modification timestamps.) 379 */ 380 o->orig_index = the_index; 381 the_index = tmp_index; 382 o->unpack_opts.src_index = &o->orig_index; 383 384return rc; 385} 386 387static voidunpack_trees_finish(struct merge_options *o) 388{ 389discard_index(&o->orig_index); 390clear_unpack_trees_porcelain(&o->unpack_opts); 391} 392 393struct tree *write_tree_from_memory(struct merge_options *o) 394{ 395struct tree *result = NULL; 396 397if(unmerged_cache()) { 398int i; 399fprintf(stderr,"BUG: There are unmerged index entries:\n"); 400for(i =0; i < active_nr; i++) { 401const struct cache_entry *ce = active_cache[i]; 402if(ce_stage(ce)) 403fprintf(stderr,"BUG:%d%.*s\n",ce_stage(ce), 404(int)ce_namelen(ce), ce->name); 405} 406BUG("unmerged index entries in merge-recursive.c"); 407} 408 409if(!active_cache_tree) 410 active_cache_tree =cache_tree(); 411 412if(!cache_tree_fully_valid(active_cache_tree) && 413cache_tree_update(&the_index,0) <0) { 414err(o,_("error building trees")); 415return NULL; 416} 417 418 result =lookup_tree(&active_cache_tree->oid); 419 420return result; 421} 422 423static intsave_files_dirs(const struct object_id *oid, 424struct strbuf *base,const char*path, 425unsigned int mode,int stage,void*context) 426{ 427struct path_hashmap_entry *entry; 428int baselen = base->len; 429struct merge_options *o = context; 430 431strbuf_addstr(base, path); 432 433FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 434hashmap_entry_init(entry,path_hash(entry->path)); 435hashmap_add(&o->current_file_dir_set, entry); 436 437strbuf_setlen(base, baselen); 438return(S_ISDIR(mode) ? READ_TREE_RECURSIVE :0); 439} 440 441static voidget_files_dirs(struct merge_options *o,struct tree *tree) 442{ 443struct pathspec match_all; 444memset(&match_all,0,sizeof(match_all)); 445read_tree_recursive(tree,"",0,0, &match_all, save_files_dirs, o); 446} 447 448static intget_tree_entry_if_blob(const struct object_id *tree, 449const char*path, 450struct object_id *hashy, 451unsigned int*mode_o) 452{ 453int ret; 454 455 ret =get_tree_entry(tree, path, hashy, mode_o); 456if(S_ISDIR(*mode_o)) { 457oidcpy(hashy, &null_oid); 458*mode_o =0; 459} 460return ret; 461} 462 463/* 464 * Returns an index_entry instance which doesn't have to correspond to 465 * a real cache entry in Git's index. 466 */ 467static struct stage_data *insert_stage_data(const char*path, 468struct tree *o,struct tree *a,struct tree *b, 469struct string_list *entries) 470{ 471struct string_list_item *item; 472struct stage_data *e =xcalloc(1,sizeof(struct stage_data)); 473get_tree_entry_if_blob(&o->object.oid, path, 474&e->stages[1].oid, &e->stages[1].mode); 475get_tree_entry_if_blob(&a->object.oid, path, 476&e->stages[2].oid, &e->stages[2].mode); 477get_tree_entry_if_blob(&b->object.oid, path, 478&e->stages[3].oid, &e->stages[3].mode); 479 item =string_list_insert(entries, path); 480 item->util = e; 481return e; 482} 483 484/* 485 * Create a dictionary mapping file names to stage_data objects. The 486 * dictionary contains one entry for every path with a non-zero stage entry. 487 */ 488static struct string_list *get_unmerged(void) 489{ 490struct string_list *unmerged =xcalloc(1,sizeof(struct string_list)); 491int i; 492 493 unmerged->strdup_strings =1; 494 495for(i =0; i < active_nr; i++) { 496struct string_list_item *item; 497struct stage_data *e; 498const struct cache_entry *ce = active_cache[i]; 499if(!ce_stage(ce)) 500continue; 501 502 item =string_list_lookup(unmerged, ce->name); 503if(!item) { 504 item =string_list_insert(unmerged, ce->name); 505 item->util =xcalloc(1,sizeof(struct stage_data)); 506} 507 e = item->util; 508 e->stages[ce_stage(ce)].mode = ce->ce_mode; 509oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 510} 511 512return unmerged; 513} 514 515static intstring_list_df_name_compare(const char*one,const char*two) 516{ 517int onelen =strlen(one); 518int twolen =strlen(two); 519/* 520 * Here we only care that entries for D/F conflicts are 521 * adjacent, in particular with the file of the D/F conflict 522 * appearing before files below the corresponding directory. 523 * The order of the rest of the list is irrelevant for us. 524 * 525 * To achieve this, we sort with df_name_compare and provide 526 * the mode S_IFDIR so that D/F conflicts will sort correctly. 527 * We use the mode S_IFDIR for everything else for simplicity, 528 * since in other cases any changes in their order due to 529 * sorting cause no problems for us. 530 */ 531int cmp =df_name_compare(one, onelen, S_IFDIR, 532 two, twolen, S_IFDIR); 533/* 534 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 535 * that 'foo' comes before 'foo/bar'. 536 */ 537if(cmp) 538return cmp; 539return onelen - twolen; 540} 541 542static voidrecord_df_conflict_files(struct merge_options *o, 543struct string_list *entries) 544{ 545/* If there is a D/F conflict and the file for such a conflict 546 * currently exist in the working tree, we want to allow it to be 547 * removed to make room for the corresponding directory if needed. 548 * The files underneath the directories of such D/F conflicts will 549 * be processed before the corresponding file involved in the D/F 550 * conflict. If the D/F directory ends up being removed by the 551 * merge, then we won't have to touch the D/F file. If the D/F 552 * directory needs to be written to the working copy, then the D/F 553 * file will simply be removed (in make_room_for_path()) to make 554 * room for the necessary paths. Note that if both the directory 555 * and the file need to be present, then the D/F file will be 556 * reinstated with a new unique name at the time it is processed. 557 */ 558struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 559const char*last_file = NULL; 560int last_len =0; 561int i; 562 563/* 564 * If we're merging merge-bases, we don't want to bother with 565 * any working directory changes. 566 */ 567if(o->call_depth) 568return; 569 570/* Ensure D/F conflicts are adjacent in the entries list. */ 571for(i =0; i < entries->nr; i++) { 572struct string_list_item *next = &entries->items[i]; 573string_list_append(&df_sorted_entries, next->string)->util = 574 next->util; 575} 576 df_sorted_entries.cmp = string_list_df_name_compare; 577string_list_sort(&df_sorted_entries); 578 579string_list_clear(&o->df_conflict_file_set,1); 580for(i =0; i < df_sorted_entries.nr; i++) { 581const char*path = df_sorted_entries.items[i].string; 582int len =strlen(path); 583struct stage_data *e = df_sorted_entries.items[i].util; 584 585/* 586 * Check if last_file & path correspond to a D/F conflict; 587 * i.e. whether path is last_file+'/'+<something>. 588 * If so, record that it's okay to remove last_file to make 589 * room for path and friends if needed. 590 */ 591if(last_file && 592 len > last_len && 593memcmp(path, last_file, last_len) ==0&& 594 path[last_len] =='/') { 595string_list_insert(&o->df_conflict_file_set, last_file); 596} 597 598/* 599 * Determine whether path could exist as a file in the 600 * working directory as a possible D/F conflict. This 601 * will only occur when it exists in stage 2 as a 602 * file. 603 */ 604if(S_ISREG(e->stages[2].mode) ||S_ISLNK(e->stages[2].mode)) { 605 last_file = path; 606 last_len = len; 607}else{ 608 last_file = NULL; 609} 610} 611string_list_clear(&df_sorted_entries,0); 612} 613 614struct rename { 615struct diff_filepair *pair; 616/* 617 * Purpose of src_entry and dst_entry: 618 * 619 * If 'before' is renamed to 'after' then src_entry will contain 620 * the versions of 'before' from the merge_base, HEAD, and MERGE in 621 * stages 1, 2, and 3; dst_entry will contain the respective 622 * versions of 'after' in corresponding locations. Thus, we have a 623 * total of six modes and oids, though some will be null. (Stage 0 624 * is ignored; we're interested in handling conflicts.) 625 * 626 * Since we don't turn on break-rewrites by default, neither 627 * src_entry nor dst_entry can have all three of their stages have 628 * non-null oids, meaning at most four of the six will be non-null. 629 * Also, since this is a rename, both src_entry and dst_entry will 630 * have at least one non-null oid, meaning at least two will be 631 * non-null. Of the six oids, a typical rename will have three be 632 * non-null. Only two implies a rename/delete, and four implies a 633 * rename/add. 634 */ 635struct stage_data *src_entry; 636struct stage_data *dst_entry; 637unsigned add_turned_into_rename:1; 638unsigned processed:1; 639}; 640 641static intupdate_stages(struct merge_options *opt,const char*path, 642const struct diff_filespec *o, 643const struct diff_filespec *a, 644const struct diff_filespec *b) 645{ 646 647/* 648 * NOTE: It is usually a bad idea to call update_stages on a path 649 * before calling update_file on that same path, since it can 650 * sometimes lead to spurious "refusing to lose untracked file..." 651 * messages from update_file (via make_room_for path via 652 * would_lose_untracked). Instead, reverse the order of the calls 653 * (executing update_file first and then update_stages). 654 */ 655int clear =1; 656int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 657if(clear) 658if(remove_file_from_cache(path)) 659return-1; 660if(o) 661if(add_cacheinfo(opt, o->mode, &o->oid, path,1,0, options)) 662return-1; 663if(a) 664if(add_cacheinfo(opt, a->mode, &a->oid, path,2,0, options)) 665return-1; 666if(b) 667if(add_cacheinfo(opt, b->mode, &b->oid, path,3,0, options)) 668return-1; 669return0; 670} 671 672static intupdate_stages_for_stage_data(struct merge_options *opt, 673const char*path, 674const struct stage_data *stage_data) 675{ 676struct diff_filespec o, a, b; 677 678 o.mode = stage_data->stages[1].mode; 679oidcpy(&o.oid, &stage_data->stages[1].oid); 680 681 a.mode = stage_data->stages[2].mode; 682oidcpy(&a.oid, &stage_data->stages[2].oid); 683 684 b.mode = stage_data->stages[3].mode; 685oidcpy(&b.oid, &stage_data->stages[3].oid); 686 687returnupdate_stages(opt, path, 688is_null_oid(&o.oid) ? NULL : &o, 689is_null_oid(&a.oid) ? NULL : &a, 690is_null_oid(&b.oid) ? NULL : &b); 691} 692 693static voidupdate_entry(struct stage_data *entry, 694struct diff_filespec *o, 695struct diff_filespec *a, 696struct diff_filespec *b) 697{ 698 entry->processed =0; 699 entry->stages[1].mode = o->mode; 700 entry->stages[2].mode = a->mode; 701 entry->stages[3].mode = b->mode; 702oidcpy(&entry->stages[1].oid, &o->oid); 703oidcpy(&entry->stages[2].oid, &a->oid); 704oidcpy(&entry->stages[3].oid, &b->oid); 705} 706 707static intremove_file(struct merge_options *o,int clean, 708const char*path,int no_wd) 709{ 710int update_cache = o->call_depth || clean; 711int update_working_directory = !o->call_depth && !no_wd; 712 713if(update_cache) { 714if(remove_file_from_cache(path)) 715return-1; 716} 717if(update_working_directory) { 718if(ignore_case) { 719struct cache_entry *ce; 720 ce =cache_file_exists(path,strlen(path), ignore_case); 721if(ce &&ce_stage(ce) ==0&&strcmp(path, ce->name)) 722return0; 723} 724if(remove_path(path)) 725return-1; 726} 727return0; 728} 729 730/* add a string to a strbuf, but converting "/" to "_" */ 731static voidadd_flattened_path(struct strbuf *out,const char*s) 732{ 733size_t i = out->len; 734strbuf_addstr(out, s); 735for(; i < out->len; i++) 736if(out->buf[i] =='/') 737 out->buf[i] ='_'; 738} 739 740static char*unique_path(struct merge_options *o,const char*path,const char*branch) 741{ 742struct path_hashmap_entry *entry; 743struct strbuf newpath = STRBUF_INIT; 744int suffix =0; 745size_t base_len; 746 747strbuf_addf(&newpath,"%s~", path); 748add_flattened_path(&newpath, branch); 749 750 base_len = newpath.len; 751while(hashmap_get_from_hash(&o->current_file_dir_set, 752path_hash(newpath.buf), newpath.buf) || 753(!o->call_depth &&file_exists(newpath.buf))) { 754strbuf_setlen(&newpath, base_len); 755strbuf_addf(&newpath,"_%d", suffix++); 756} 757 758FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 759hashmap_entry_init(entry,path_hash(entry->path)); 760hashmap_add(&o->current_file_dir_set, entry); 761returnstrbuf_detach(&newpath, NULL); 762} 763 764/** 765 * Check whether a directory in the index is in the way of an incoming 766 * file. Return 1 if so. If check_working_copy is non-zero, also 767 * check the working directory. If empty_ok is non-zero, also return 768 * 0 in the case where the working-tree dir exists but is empty. 769 */ 770static intdir_in_way(const char*path,int check_working_copy,int empty_ok) 771{ 772int pos; 773struct strbuf dirpath = STRBUF_INIT; 774struct stat st; 775 776strbuf_addstr(&dirpath, path); 777strbuf_addch(&dirpath,'/'); 778 779 pos =cache_name_pos(dirpath.buf, dirpath.len); 780 781if(pos <0) 782 pos = -1- pos; 783if(pos < active_nr && 784!strncmp(dirpath.buf, active_cache[pos]->name, dirpath.len)) { 785strbuf_release(&dirpath); 786return1; 787} 788 789strbuf_release(&dirpath); 790return check_working_copy && !lstat(path, &st) &&S_ISDIR(st.st_mode) && 791!(empty_ok &&is_empty_dir(path)); 792} 793 794/* 795 * Returns whether path was tracked in the index before the merge started, 796 * and its oid and mode match the specified values 797 */ 798static intwas_tracked_and_matches(struct merge_options *o,const char*path, 799const struct object_id *oid,unsigned mode) 800{ 801int pos =index_name_pos(&o->orig_index, path,strlen(path)); 802struct cache_entry *ce; 803 804if(0> pos) 805/* we were not tracking this path before the merge */ 806return0; 807 808/* See if the file we were tracking before matches */ 809 ce = o->orig_index.cache[pos]; 810return(oid_eq(&ce->oid, oid) && ce->ce_mode == mode); 811} 812 813/* 814 * Returns whether path was tracked in the index before the merge started 815 */ 816static intwas_tracked(struct merge_options *o,const char*path) 817{ 818int pos =index_name_pos(&o->orig_index, path,strlen(path)); 819 820if(0<= pos) 821/* we were tracking this path before the merge */ 822return1; 823 824return0; 825} 826 827static intwould_lose_untracked(const char*path) 828{ 829/* 830 * This may look like it can be simplified to: 831 * return !was_tracked(o, path) && file_exists(path) 832 * but it can't. This function needs to know whether path was in 833 * the working tree due to EITHER having been tracked in the index 834 * before the merge OR having been put into the working copy and 835 * index by unpack_trees(). Due to that either-or requirement, we 836 * check the current index instead of the original one. 837 * 838 * Note that we do not need to worry about merge-recursive itself 839 * updating the index after unpack_trees() and before calling this 840 * function, because we strictly require all code paths in 841 * merge-recursive to update the working tree first and the index 842 * second. Doing otherwise would break 843 * update_file()/would_lose_untracked(); see every comment in this 844 * file which mentions "update_stages". 845 */ 846int pos =cache_name_pos(path,strlen(path)); 847 848if(pos <0) 849 pos = -1- pos; 850while(pos < active_nr && 851!strcmp(path, active_cache[pos]->name)) { 852/* 853 * If stage #0, it is definitely tracked. 854 * If it has stage #2 then it was tracked 855 * before this merge started. All other 856 * cases the path was not tracked. 857 */ 858switch(ce_stage(active_cache[pos])) { 859case0: 860case2: 861return0; 862} 863 pos++; 864} 865returnfile_exists(path); 866} 867 868static intwas_dirty(struct merge_options *o,const char*path) 869{ 870struct cache_entry *ce; 871int dirty =1; 872 873if(o->call_depth || !was_tracked(o, path)) 874return!dirty; 875 876 ce =index_file_exists(o->unpack_opts.src_index, 877 path,strlen(path), ignore_case); 878 dirty =verify_uptodate(ce, &o->unpack_opts) !=0; 879return dirty; 880} 881 882static intmake_room_for_path(struct merge_options *o,const char*path) 883{ 884int status, i; 885const char*msg =_("failed to create path '%s'%s"); 886 887/* Unlink any D/F conflict files that are in the way */ 888for(i =0; i < o->df_conflict_file_set.nr; i++) { 889const char*df_path = o->df_conflict_file_set.items[i].string; 890size_t pathlen =strlen(path); 891size_t df_pathlen =strlen(df_path); 892if(df_pathlen < pathlen && 893 path[df_pathlen] =='/'&& 894strncmp(path, df_path, df_pathlen) ==0) { 895output(o,3, 896_("Removing%sto make room for subdirectory\n"), 897 df_path); 898unlink(df_path); 899unsorted_string_list_delete_item(&o->df_conflict_file_set, 900 i,0); 901break; 902} 903} 904 905/* Make sure leading directories are created */ 906 status =safe_create_leading_directories_const(path); 907if(status) { 908if(status == SCLD_EXISTS) 909/* something else exists */ 910returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 911returnerr(o, msg, path,""); 912} 913 914/* 915 * Do not unlink a file in the work tree if we are not 916 * tracking it. 917 */ 918if(would_lose_untracked(path)) 919returnerr(o,_("refusing to lose untracked file at '%s'"), 920 path); 921 922/* Successful unlink is good.. */ 923if(!unlink(path)) 924return0; 925/* .. and so is no existing file */ 926if(errno == ENOENT) 927return0; 928/* .. but not some other error (who really cares what?) */ 929returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 930} 931 932static intupdate_file_flags(struct merge_options *o, 933const struct object_id *oid, 934unsigned mode, 935const char*path, 936int update_cache, 937int update_wd) 938{ 939int ret =0; 940 941if(o->call_depth) 942 update_wd =0; 943 944if(update_wd) { 945enum object_type type; 946void*buf; 947unsigned long size; 948 949if(S_ISGITLINK(mode)) { 950/* 951 * We may later decide to recursively descend into 952 * the submodule directory and update its index 953 * and/or work tree, but we do not do that now. 954 */ 955 update_wd =0; 956goto update_index; 957} 958 959 buf =read_object_file(oid, &type, &size); 960if(!buf) 961returnerr(o,_("cannot read object%s'%s'"),oid_to_hex(oid), path); 962if(type != OBJ_BLOB) { 963 ret =err(o,_("blob expected for%s'%s'"),oid_to_hex(oid), path); 964goto free_buf; 965} 966if(S_ISREG(mode)) { 967struct strbuf strbuf = STRBUF_INIT; 968if(convert_to_working_tree(path, buf, size, &strbuf)) { 969free(buf); 970 size = strbuf.len; 971 buf =strbuf_detach(&strbuf, NULL); 972} 973} 974 975if(make_room_for_path(o, path) <0) { 976 update_wd =0; 977goto free_buf; 978} 979if(S_ISREG(mode) || (!has_symlinks &&S_ISLNK(mode))) { 980int fd; 981if(mode &0100) 982 mode =0777; 983else 984 mode =0666; 985 fd =open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 986if(fd <0) { 987 ret =err(o,_("failed to open '%s':%s"), 988 path,strerror(errno)); 989goto free_buf; 990} 991write_in_full(fd, buf, size); 992close(fd); 993}else if(S_ISLNK(mode)) { 994char*lnk =xmemdupz(buf, size); 995safe_create_leading_directories_const(path); 996unlink(path); 997if(symlink(lnk, path)) 998 ret =err(o,_("failed to symlink '%s':%s"), 999 path,strerror(errno));1000free(lnk);1001}else1002 ret =err(o,1003_("do not know what to do with%06o%s'%s'"),1004 mode,oid_to_hex(oid), path);1005 free_buf:1006free(buf);1007}1008 update_index:1009if(!ret && update_cache)1010if(add_cacheinfo(o, mode, oid, path,0, update_wd,1011 ADD_CACHE_OK_TO_ADD))1012return-1;1013return ret;1014}10151016static intupdate_file(struct merge_options *o,1017int clean,1018const struct object_id *oid,1019unsigned mode,1020const char*path)1021{1022returnupdate_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth);1023}10241025/* Low level file merging, update and removal */10261027struct merge_file_info {1028struct object_id oid;1029unsigned mode;1030unsigned clean:1,1031 merge:1;1032};10331034static intmerge_3way(struct merge_options *o,1035 mmbuffer_t *result_buf,1036const struct diff_filespec *one,1037const struct diff_filespec *a,1038const struct diff_filespec *b,1039const char*branch1,1040const char*branch2)1041{1042 mmfile_t orig, src1, src2;1043struct ll_merge_options ll_opts = {0};1044char*base_name, *name1, *name2;1045int merge_status;10461047 ll_opts.renormalize = o->renormalize;1048 ll_opts.xdl_opts = o->xdl_opts;10491050if(o->call_depth) {1051 ll_opts.virtual_ancestor =1;1052 ll_opts.variant =0;1053}else{1054switch(o->recursive_variant) {1055case MERGE_RECURSIVE_OURS:1056 ll_opts.variant = XDL_MERGE_FAVOR_OURS;1057break;1058case MERGE_RECURSIVE_THEIRS:1059 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;1060break;1061default:1062 ll_opts.variant =0;1063break;1064}1065}10661067if(strcmp(a->path, b->path) ||1068(o->ancestor != NULL &&strcmp(a->path, one->path) !=0)) {1069 base_name = o->ancestor == NULL ? NULL :1070mkpathdup("%s:%s", o->ancestor, one->path);1071 name1 =mkpathdup("%s:%s", branch1, a->path);1072 name2 =mkpathdup("%s:%s", branch2, b->path);1073}else{1074 base_name = o->ancestor == NULL ? NULL :1075mkpathdup("%s", o->ancestor);1076 name1 =mkpathdup("%s", branch1);1077 name2 =mkpathdup("%s", branch2);1078}10791080read_mmblob(&orig, &one->oid);1081read_mmblob(&src1, &a->oid);1082read_mmblob(&src2, &b->oid);10831084 merge_status =ll_merge(result_buf, a->path, &orig, base_name,1085&src1, name1, &src2, name2, &ll_opts);10861087free(base_name);1088free(name1);1089free(name2);1090free(orig.ptr);1091free(src1.ptr);1092free(src2.ptr);1093return merge_status;1094}10951096static intfind_first_merges(struct object_array *result,const char*path,1097struct commit *a,struct commit *b)1098{1099int i, j;1100struct object_array merges = OBJECT_ARRAY_INIT;1101struct commit *commit;1102int contains_another;11031104char merged_revision[42];1105const char*rev_args[] = {"rev-list","--merges","--ancestry-path",1106"--all", merged_revision, NULL };1107struct rev_info revs;1108struct setup_revision_opt rev_opts;11091110memset(result,0,sizeof(struct object_array));1111memset(&rev_opts,0,sizeof(rev_opts));11121113/* get all revisions that merge commit a */1114xsnprintf(merged_revision,sizeof(merged_revision),"^%s",1115oid_to_hex(&a->object.oid));1116init_revisions(&revs, NULL);1117 rev_opts.submodule = path;1118/* FIXME: can't handle linked worktrees in submodules yet */1119 revs.single_worktree = path != NULL;1120setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);11211122/* save all revisions from the above list that contain b */1123if(prepare_revision_walk(&revs))1124die("revision walk setup failed");1125while((commit =get_revision(&revs)) != NULL) {1126struct object *o = &(commit->object);1127if(in_merge_bases(b, commit))1128add_object_array(o, NULL, &merges);1129}1130reset_revision_walk();11311132/* Now we've got all merges that contain a and b. Prune all1133 * merges that contain another found merge and save them in1134 * result.1135 */1136for(i =0; i < merges.nr; i++) {1137struct commit *m1 = (struct commit *) merges.objects[i].item;11381139 contains_another =0;1140for(j =0; j < merges.nr; j++) {1141struct commit *m2 = (struct commit *) merges.objects[j].item;1142if(i != j &&in_merge_bases(m2, m1)) {1143 contains_another =1;1144break;1145}1146}11471148if(!contains_another)1149add_object_array(merges.objects[i].item, NULL, result);1150}11511152object_array_clear(&merges);1153return result->nr;1154}11551156static voidprint_commit(struct commit *commit)1157{1158struct strbuf sb = STRBUF_INIT;1159struct pretty_print_context ctx = {0};1160 ctx.date_mode.type = DATE_NORMAL;1161format_commit_message(commit,"%h:%m %s", &sb, &ctx);1162fprintf(stderr,"%s\n", sb.buf);1163strbuf_release(&sb);1164}11651166static intmerge_submodule(struct merge_options *o,1167struct object_id *result,const char*path,1168const struct object_id *base,const struct object_id *a,1169const struct object_id *b)1170{1171struct commit *commit_base, *commit_a, *commit_b;1172int parent_count;1173struct object_array merges;11741175int i;1176int search = !o->call_depth;11771178/* store a in result in case we fail */1179oidcpy(result, a);11801181/* we can not handle deletion conflicts */1182if(is_null_oid(base))1183return0;1184if(is_null_oid(a))1185return0;1186if(is_null_oid(b))1187return0;11881189if(add_submodule_odb(path)) {1190output(o,1,_("Failed to merge submodule%s(not checked out)"), path);1191return0;1192}11931194if(!(commit_base =lookup_commit_reference(base)) ||1195!(commit_a =lookup_commit_reference(a)) ||1196!(commit_b =lookup_commit_reference(b))) {1197output(o,1,_("Failed to merge submodule%s(commits not present)"), path);1198return0;1199}12001201/* check whether both changes are forward */1202if(!in_merge_bases(commit_base, commit_a) ||1203!in_merge_bases(commit_base, commit_b)) {1204output(o,1,_("Failed to merge submodule%s(commits don't follow merge-base)"), path);1205return0;1206}12071208/* Case #1: a is contained in b or vice versa */1209if(in_merge_bases(commit_a, commit_b)) {1210oidcpy(result, b);1211if(show(o,3)) {1212output(o,3,_("Fast-forwarding submodule%sto the following commit:"), path);1213output_commit_title(o, commit_b);1214}else if(show(o,2))1215output(o,2,_("Fast-forwarding submodule%s"), path);1216else1217;/* no output */12181219return1;1220}1221if(in_merge_bases(commit_b, commit_a)) {1222oidcpy(result, a);1223if(show(o,3)) {1224output(o,3,_("Fast-forwarding submodule%sto the following commit:"), path);1225output_commit_title(o, commit_a);1226}else if(show(o,2))1227output(o,2,_("Fast-forwarding submodule%s"), path);1228else1229;/* no output */12301231return1;1232}12331234/*1235 * Case #2: There are one or more merges that contain a and b in1236 * the submodule. If there is only one, then present it as a1237 * suggestion to the user, but leave it marked unmerged so the1238 * user needs to confirm the resolution.1239 */12401241/* Skip the search if makes no sense to the calling context. */1242if(!search)1243return0;12441245/* find commit which merges them */1246 parent_count =find_first_merges(&merges, path, commit_a, commit_b);1247switch(parent_count) {1248case0:1249output(o,1,_("Failed to merge submodule%s(merge following commits not found)"), path);1250break;12511252case1:1253output(o,1,_("Failed to merge submodule%s(not fast-forward)"), path);1254output(o,2,_("Found a possible merge resolution for the submodule:\n"));1255print_commit((struct commit *) merges.objects[0].item);1256output(o,2,_(1257"If this is correct simply add it to the index "1258"for example\n"1259"by using:\n\n"1260" git update-index --cacheinfo 160000%s\"%s\"\n\n"1261"which will accept this suggestion.\n"),1262oid_to_hex(&merges.objects[0].item->oid), path);1263break;12641265default:1266output(o,1,_("Failed to merge submodule%s(multiple merges found)"), path);1267for(i =0; i < merges.nr; i++)1268print_commit((struct commit *) merges.objects[i].item);1269}12701271object_array_clear(&merges);1272return0;1273}12741275static intmerge_file_1(struct merge_options *o,1276const struct diff_filespec *one,1277const struct diff_filespec *a,1278const struct diff_filespec *b,1279const char*filename,1280const char*branch1,1281const char*branch2,1282struct merge_file_info *result)1283{1284 result->merge =0;1285 result->clean =1;12861287if((S_IFMT & a->mode) != (S_IFMT & b->mode)) {1288 result->clean =0;1289if(S_ISREG(a->mode)) {1290 result->mode = a->mode;1291oidcpy(&result->oid, &a->oid);1292}else{1293 result->mode = b->mode;1294oidcpy(&result->oid, &b->oid);1295}1296}else{1297if(!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))1298 result->merge =1;12991300/*1301 * Merge modes1302 */1303if(a->mode == b->mode || a->mode == one->mode)1304 result->mode = b->mode;1305else{1306 result->mode = a->mode;1307if(b->mode != one->mode) {1308 result->clean =0;1309 result->merge =1;1310}1311}13121313if(oid_eq(&a->oid, &b->oid) ||oid_eq(&a->oid, &one->oid))1314oidcpy(&result->oid, &b->oid);1315else if(oid_eq(&b->oid, &one->oid))1316oidcpy(&result->oid, &a->oid);1317else if(S_ISREG(a->mode)) {1318 mmbuffer_t result_buf;1319int ret =0, merge_status;13201321 merge_status =merge_3way(o, &result_buf, one, a, b,1322 branch1, branch2);13231324if((merge_status <0) || !result_buf.ptr)1325 ret =err(o,_("Failed to execute internal merge"));13261327if(!ret &&1328write_object_file(result_buf.ptr, result_buf.size,1329 blob_type, &result->oid))1330 ret =err(o,_("Unable to add%sto database"),1331 a->path);13321333free(result_buf.ptr);1334if(ret)1335return ret;1336 result->clean = (merge_status ==0);1337}else if(S_ISGITLINK(a->mode)) {1338 result->clean =merge_submodule(o, &result->oid,1339 one->path,1340&one->oid,1341&a->oid,1342&b->oid);1343}else if(S_ISLNK(a->mode)) {1344switch(o->recursive_variant) {1345case MERGE_RECURSIVE_NORMAL:1346oidcpy(&result->oid, &a->oid);1347if(!oid_eq(&a->oid, &b->oid))1348 result->clean =0;1349break;1350case MERGE_RECURSIVE_OURS:1351oidcpy(&result->oid, &a->oid);1352break;1353case MERGE_RECURSIVE_THEIRS:1354oidcpy(&result->oid, &b->oid);1355break;1356}1357}else1358BUG("unsupported object type in the tree");1359}13601361if(result->merge)1362output(o,2,_("Auto-merging%s"), filename);13631364return0;1365}13661367static intmerge_file_special_markers(struct merge_options *o,1368const struct diff_filespec *one,1369const struct diff_filespec *a,1370const struct diff_filespec *b,1371const char*target_filename,1372const char*branch1,1373const char*filename1,1374const char*branch2,1375const char*filename2,1376struct merge_file_info *mfi)1377{1378char*side1 = NULL;1379char*side2 = NULL;1380int ret;13811382if(filename1)1383 side1 =xstrfmt("%s:%s", branch1, filename1);1384if(filename2)1385 side2 =xstrfmt("%s:%s", branch2, filename2);13861387 ret =merge_file_1(o, one, a, b, target_filename,1388 side1 ? side1 : branch1,1389 side2 ? side2 : branch2, mfi);13901391free(side1);1392free(side2);1393return ret;1394}13951396static intmerge_file_one(struct merge_options *o,1397const char*path,1398const struct object_id *o_oid,int o_mode,1399const struct object_id *a_oid,int a_mode,1400const struct object_id *b_oid,int b_mode,1401const char*branch1,1402const char*branch2,1403struct merge_file_info *mfi)1404{1405struct diff_filespec one, a, b;14061407 one.path = a.path = b.path = (char*)path;1408oidcpy(&one.oid, o_oid);1409 one.mode = o_mode;1410oidcpy(&a.oid, a_oid);1411 a.mode = a_mode;1412oidcpy(&b.oid, b_oid);1413 b.mode = b_mode;1414returnmerge_file_1(o, &one, &a, &b, path, branch1, branch2, mfi);1415}14161417static intconflict_rename_dir(struct merge_options *o,1418struct diff_filepair *pair,1419const char*rename_branch,1420const char*other_branch)1421{1422const struct diff_filespec *dest = pair->two;14231424if(!o->call_depth &&would_lose_untracked(dest->path)) {1425char*alt_path =unique_path(o, dest->path, rename_branch);14261427output(o,1,_("Error: Refusing to lose untracked file at%s; "1428"writing to%sinstead."),1429 dest->path, alt_path);1430/*1431 * Write the file in worktree at alt_path, but not in the1432 * index. Instead, write to dest->path for the index but1433 * only at the higher appropriate stage.1434 */1435if(update_file(o,0, &dest->oid, dest->mode, alt_path))1436return-1;1437free(alt_path);1438returnupdate_stages(o, dest->path, NULL,1439 rename_branch == o->branch1 ? dest : NULL,1440 rename_branch == o->branch1 ? NULL : dest);1441}14421443/* Update dest->path both in index and in worktree */1444if(update_file(o,1, &dest->oid, dest->mode, dest->path))1445return-1;1446return0;1447}14481449static inthandle_change_delete(struct merge_options *o,1450const char*path,const char*old_path,1451const struct object_id *o_oid,int o_mode,1452const struct object_id *changed_oid,1453int changed_mode,1454const char*change_branch,1455const char*delete_branch,1456const char*change,const char*change_past)1457{1458char*alt_path = NULL;1459const char*update_path = path;1460int ret =0;14611462if(dir_in_way(path, !o->call_depth,0) ||1463(!o->call_depth &&would_lose_untracked(path))) {1464 update_path = alt_path =unique_path(o, path, change_branch);1465}14661467if(o->call_depth) {1468/*1469 * We cannot arbitrarily accept either a_sha or b_sha as1470 * correct; since there is no true "middle point" between1471 * them, simply reuse the base version for virtual merge base.1472 */1473 ret =remove_file_from_cache(path);1474if(!ret)1475 ret =update_file(o,0, o_oid, o_mode, update_path);1476}else{1477if(!alt_path) {1478if(!old_path) {1479output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1480"and%sin%s. Version%sof%sleft in tree."),1481 change, path, delete_branch, change_past,1482 change_branch, change_branch, path);1483}else{1484output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1485"and%sto%sin%s. Version%sof%sleft in tree."),1486 change, old_path, delete_branch, change_past, path,1487 change_branch, change_branch, path);1488}1489}else{1490if(!old_path) {1491output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1492"and%sin%s. Version%sof%sleft in tree at%s."),1493 change, path, delete_branch, change_past,1494 change_branch, change_branch, path, alt_path);1495}else{1496output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1497"and%sto%sin%s. Version%sof%sleft in tree at%s."),1498 change, old_path, delete_branch, change_past, path,1499 change_branch, change_branch, path, alt_path);1500}1501}1502/*1503 * No need to call update_file() on path when change_branch ==1504 * o->branch1 && !alt_path, since that would needlessly touch1505 * path. We could call update_file_flags() with update_cache=01506 * and update_wd=0, but that's a no-op.1507 */1508if(change_branch != o->branch1 || alt_path)1509 ret =update_file(o,0, changed_oid, changed_mode, update_path);1510}1511free(alt_path);15121513return ret;1514}15151516static intconflict_rename_delete(struct merge_options *o,1517struct diff_filepair *pair,1518const char*rename_branch,1519const char*delete_branch)1520{1521const struct diff_filespec *orig = pair->one;1522const struct diff_filespec *dest = pair->two;15231524if(handle_change_delete(o,1525 o->call_depth ? orig->path : dest->path,1526 o->call_depth ? NULL : orig->path,1527&orig->oid, orig->mode,1528&dest->oid, dest->mode,1529 rename_branch, delete_branch,1530_("rename"),_("renamed")))1531return-1;15321533if(o->call_depth)1534returnremove_file_from_cache(dest->path);1535else1536returnupdate_stages(o, dest->path, NULL,1537 rename_branch == o->branch1 ? dest : NULL,1538 rename_branch == o->branch1 ? NULL : dest);1539}15401541static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,1542struct stage_data *entry,1543int stage)1544{1545struct object_id *oid = &entry->stages[stage].oid;1546unsigned mode = entry->stages[stage].mode;1547if(mode ==0||is_null_oid(oid))1548return NULL;1549oidcpy(&target->oid, oid);1550 target->mode = mode;1551return target;1552}15531554static inthandle_file(struct merge_options *o,1555struct diff_filespec *rename,1556int stage,1557struct rename_conflict_info *ci)1558{1559char*dst_name = rename->path;1560struct stage_data *dst_entry;1561const char*cur_branch, *other_branch;1562struct diff_filespec other;1563struct diff_filespec *add;1564int ret;15651566if(stage ==2) {1567 dst_entry = ci->dst_entry1;1568 cur_branch = ci->branch1;1569 other_branch = ci->branch2;1570}else{1571 dst_entry = ci->dst_entry2;1572 cur_branch = ci->branch2;1573 other_branch = ci->branch1;1574}15751576 add =filespec_from_entry(&other, dst_entry, stage ^1);1577if(add) {1578int ren_src_was_dirty =was_dirty(o, rename->path);1579char*add_name =unique_path(o, rename->path, other_branch);1580if(update_file(o,0, &add->oid, add->mode, add_name))1581return-1;15821583if(ren_src_was_dirty) {1584output(o,1,_("Refusing to lose dirty file at%s"),1585 rename->path);1586}1587/*1588 * Because the double negatives somehow keep confusing me...1589 * 1) update_wd iff !ren_src_was_dirty.1590 * 2) no_wd iff !update_wd1591 * 3) so, no_wd == !!ren_src_was_dirty == ren_src_was_dirty1592 */1593remove_file(o,0, rename->path, ren_src_was_dirty);1594 dst_name =unique_path(o, rename->path, cur_branch);1595}else{1596if(dir_in_way(rename->path, !o->call_depth,0)) {1597 dst_name =unique_path(o, rename->path, cur_branch);1598output(o,1,_("%sis a directory in%sadding as%sinstead"),1599 rename->path, other_branch, dst_name);1600}else if(!o->call_depth &&1601would_lose_untracked(rename->path)) {1602 dst_name =unique_path(o, rename->path, cur_branch);1603output(o,1,_("Refusing to lose untracked file at%s; "1604"adding as%sinstead"),1605 rename->path, dst_name);1606}1607}1608if((ret =update_file(o,0, &rename->oid, rename->mode, dst_name)))1609;/* fall through, do allow dst_name to be released */1610else if(stage ==2)1611 ret =update_stages(o, rename->path, NULL, rename, add);1612else1613 ret =update_stages(o, rename->path, NULL, add, rename);16141615if(dst_name != rename->path)1616free(dst_name);16171618return ret;1619}16201621static intconflict_rename_rename_1to2(struct merge_options *o,1622struct rename_conflict_info *ci)1623{1624/* One file was renamed in both branches, but to different names. */1625struct diff_filespec *one = ci->pair1->one;1626struct diff_filespec *a = ci->pair1->two;1627struct diff_filespec *b = ci->pair2->two;16281629output(o,1,_("CONFLICT (rename/rename): "1630"Rename\"%s\"->\"%s\"in branch\"%s\""1631"rename\"%s\"->\"%s\"in\"%s\"%s"),1632 one->path, a->path, ci->branch1,1633 one->path, b->path, ci->branch2,1634 o->call_depth ?_(" (left unresolved)") :"");1635if(o->call_depth) {1636struct merge_file_info mfi;1637struct diff_filespec other;1638struct diff_filespec *add;1639if(merge_file_one(o, one->path,1640&one->oid, one->mode,1641&a->oid, a->mode,1642&b->oid, b->mode,1643 ci->branch1, ci->branch2, &mfi))1644return-1;16451646/*1647 * FIXME: For rename/add-source conflicts (if we could detect1648 * such), this is wrong. We should instead find a unique1649 * pathname and then either rename the add-source file to that1650 * unique path, or use that unique path instead of src here.1651 */1652if(update_file(o,0, &mfi.oid, mfi.mode, one->path))1653return-1;16541655/*1656 * Above, we put the merged content at the merge-base's1657 * path. Now we usually need to delete both a->path and1658 * b->path. However, the rename on each side of the merge1659 * could also be involved in a rename/add conflict. In1660 * such cases, we should keep the added file around,1661 * resolving the conflict at that path in its favor.1662 */1663 add =filespec_from_entry(&other, ci->dst_entry1,2^1);1664if(add) {1665if(update_file(o,0, &add->oid, add->mode, a->path))1666return-1;1667}1668else1669remove_file_from_cache(a->path);1670 add =filespec_from_entry(&other, ci->dst_entry2,3^1);1671if(add) {1672if(update_file(o,0, &add->oid, add->mode, b->path))1673return-1;1674}1675else1676remove_file_from_cache(b->path);1677}else if(handle_file(o, a,2, ci) ||handle_file(o, b,3, ci))1678return-1;16791680return0;1681}16821683static intconflict_rename_rename_2to1(struct merge_options *o,1684struct rename_conflict_info *ci)1685{1686/* Two files, a & b, were renamed to the same thing, c. */1687struct diff_filespec *a = ci->pair1->one;1688struct diff_filespec *b = ci->pair2->one;1689struct diff_filespec *c1 = ci->pair1->two;1690struct diff_filespec *c2 = ci->pair2->two;1691char*path = c1->path;/* == c2->path */1692char*path_side_1_desc;1693char*path_side_2_desc;1694struct merge_file_info mfi_c1;1695struct merge_file_info mfi_c2;1696int ret;16971698output(o,1,_("CONFLICT (rename/rename): "1699"Rename%s->%sin%s. "1700"Rename%s->%sin%s"),1701 a->path, c1->path, ci->branch1,1702 b->path, c2->path, ci->branch2);17031704remove_file(o,1, a->path, o->call_depth ||would_lose_untracked(a->path));1705remove_file(o,1, b->path, o->call_depth ||would_lose_untracked(b->path));17061707 path_side_1_desc =xstrfmt("%s(was%s)", path, a->path);1708 path_side_2_desc =xstrfmt("%s(was%s)", path, b->path);1709if(merge_file_special_markers(o, a, c1, &ci->ren1_other,1710 path_side_1_desc,1711 o->branch1, c1->path,1712 o->branch2, ci->ren1_other.path, &mfi_c1) ||1713merge_file_special_markers(o, b, &ci->ren2_other, c2,1714 path_side_2_desc,1715 o->branch1, ci->ren2_other.path,1716 o->branch2, c2->path, &mfi_c2))1717return-1;1718free(path_side_1_desc);1719free(path_side_2_desc);17201721if(o->call_depth) {1722/*1723 * If mfi_c1.clean && mfi_c2.clean, then it might make1724 * sense to do a two-way merge of those results. But, I1725 * think in all cases, it makes sense to have the virtual1726 * merge base just undo the renames; they can be detected1727 * again later for the non-recursive merge.1728 */1729remove_file(o,0, path,0);1730 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, a->path);1731if(!ret)1732 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1733 b->path);1734}else{1735char*new_path1 =unique_path(o, path, ci->branch1);1736char*new_path2 =unique_path(o, path, ci->branch2);1737output(o,1,_("Renaming%sto%sand%sto%sinstead"),1738 a->path, new_path1, b->path, new_path2);1739if(was_dirty(o, path))1740output(o,1,_("Refusing to lose dirty file at%s"),1741 path);1742else if(would_lose_untracked(path))1743/*1744 * Only way we get here is if both renames were from1745 * a directory rename AND user had an untracked file1746 * at the location where both files end up after the1747 * two directory renames. See testcase 10d of t6043.1748 */1749output(o,1,_("Refusing to lose untracked file at "1750"%s, even though it's in the way."),1751 path);1752else1753remove_file(o,0, path,0);1754 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, new_path1);1755if(!ret)1756 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1757 new_path2);1758/*1759 * unpack_trees() actually populates the index for us for1760 * "normal" rename/rename(2to1) situtations so that the1761 * correct entries are at the higher stages, which would1762 * make the call below to update_stages_for_stage_data1763 * unnecessary. However, if either of the renames came1764 * from a directory rename, then unpack_trees() will not1765 * have gotten the right data loaded into the index, so we1766 * need to do so now. (While it'd be tempting to move this1767 * call to update_stages_for_stage_data() to1768 * apply_directory_rename_modifications(), that would break1769 * our intermediate calls to would_lose_untracked() since1770 * those rely on the current in-memory index. See also the1771 * big "NOTE" in update_stages()).1772 */1773if(update_stages_for_stage_data(o, path, ci->dst_entry1))1774 ret = -1;17751776free(new_path2);1777free(new_path1);1778}17791780return ret;1781}17821783/*1784 * Get the diff_filepairs changed between o_tree and tree.1785 */1786static struct diff_queue_struct *get_diffpairs(struct merge_options *o,1787struct tree *o_tree,1788struct tree *tree)1789{1790struct diff_queue_struct *ret;1791struct diff_options opts;17921793diff_setup(&opts);1794 opts.flags.recursive =1;1795 opts.flags.rename_empty =0;1796 opts.detect_rename =merge_detect_rename(o);1797/*1798 * We do not have logic to handle the detection of copies. In1799 * fact, it may not even make sense to add such logic: would we1800 * really want a change to a base file to be propagated through1801 * multiple other files by a merge?1802 */1803if(opts.detect_rename > DIFF_DETECT_RENAME)1804 opts.detect_rename = DIFF_DETECT_RENAME;1805 opts.rename_limit = o->merge_rename_limit >=0? o->merge_rename_limit :1806 o->diff_rename_limit >=0? o->diff_rename_limit :18071000;1808 opts.rename_score = o->rename_score;1809 opts.show_rename_progress = o->show_rename_progress;1810 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1811diff_setup_done(&opts);1812diff_tree_oid(&o_tree->object.oid, &tree->object.oid,"", &opts);1813diffcore_std(&opts);1814if(opts.needed_rename_limit > o->needed_rename_limit)1815 o->needed_rename_limit = opts.needed_rename_limit;18161817 ret =xmalloc(sizeof(*ret));1818*ret = diff_queued_diff;18191820 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1821 diff_queued_diff.nr =0;1822 diff_queued_diff.queue = NULL;1823diff_flush(&opts);1824return ret;1825}18261827static inttree_has_path(struct tree *tree,const char*path)1828{1829struct object_id hashy;1830unsigned int mode_o;18311832return!get_tree_entry(&tree->object.oid, path,1833&hashy, &mode_o);1834}18351836/*1837 * Return a new string that replaces the beginning portion (which matches1838 * entry->dir), with entry->new_dir. In perl-speak:1839 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1840 * NOTE:1841 * Caller must ensure that old_path starts with entry->dir + '/'.1842 */1843static char*apply_dir_rename(struct dir_rename_entry *entry,1844const char*old_path)1845{1846struct strbuf new_path = STRBUF_INIT;1847int oldlen, newlen;18481849if(entry->non_unique_new_dir)1850return NULL;18511852 oldlen =strlen(entry->dir);1853 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) +1;1854strbuf_grow(&new_path, newlen);1855strbuf_addbuf(&new_path, &entry->new_dir);1856strbuf_addstr(&new_path, &old_path[oldlen]);18571858returnstrbuf_detach(&new_path, NULL);1859}18601861static voidget_renamed_dir_portion(const char*old_path,const char*new_path,1862char**old_dir,char**new_dir)1863{1864char*end_of_old, *end_of_new;1865int old_len, new_len;18661867*old_dir = NULL;1868*new_dir = NULL;18691870/*1871 * For1872 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1873 * the "e/foo.c" part is the same, we just want to know that1874 * "a/b/c/d" was renamed to "a/b/some/thing/else"1875 * so, for this example, this function returns "a/b/c/d" in1876 * *old_dir and "a/b/some/thing/else" in *new_dir.1877 *1878 * Also, if the basename of the file changed, we don't care. We1879 * want to know which portion of the directory, if any, changed.1880 */1881 end_of_old =strrchr(old_path,'/');1882 end_of_new =strrchr(new_path,'/');18831884if(end_of_old == NULL || end_of_new == NULL)1885return;1886while(*--end_of_new == *--end_of_old &&1887 end_of_old != old_path &&1888 end_of_new != new_path)1889;/* Do nothing; all in the while loop */1890/*1891 * We've found the first non-matching character in the directory1892 * paths. That means the current directory we were comparing1893 * represents the rename. Move end_of_old and end_of_new back1894 * to the full directory name.1895 */1896if(*end_of_old =='/')1897 end_of_old++;1898if(*end_of_old !='/')1899 end_of_new++;1900 end_of_old =strchr(end_of_old,'/');1901 end_of_new =strchr(end_of_new,'/');19021903/*1904 * It may have been the case that old_path and new_path were the same1905 * directory all along. Don't claim a rename if they're the same.1906 */1907 old_len = end_of_old - old_path;1908 new_len = end_of_new - new_path;19091910if(old_len != new_len ||strncmp(old_path, new_path, old_len)) {1911*old_dir =xstrndup(old_path, old_len);1912*new_dir =xstrndup(new_path, new_len);1913}1914}19151916static voidremove_hashmap_entries(struct hashmap *dir_renames,1917struct string_list *items_to_remove)1918{1919int i;1920struct dir_rename_entry *entry;19211922for(i =0; i < items_to_remove->nr; i++) {1923 entry = items_to_remove->items[i].util;1924hashmap_remove(dir_renames, entry, NULL);1925}1926string_list_clear(items_to_remove,0);1927}19281929/*1930 * See if there is a directory rename for path, and if there are any file1931 * level conflicts for the renamed location. If there is a rename and1932 * there are no conflicts, return the new name. Otherwise, return NULL.1933 */1934static char*handle_path_level_conflicts(struct merge_options *o,1935const char*path,1936struct dir_rename_entry *entry,1937struct hashmap *collisions,1938struct tree *tree)1939{1940char*new_path = NULL;1941struct collision_entry *collision_ent;1942int clean =1;1943struct strbuf collision_paths = STRBUF_INIT;19441945/*1946 * entry has the mapping of old directory name to new directory name1947 * that we want to apply to path.1948 */1949 new_path =apply_dir_rename(entry, path);19501951if(!new_path) {1952/* This should only happen when entry->non_unique_new_dir set */1953if(!entry->non_unique_new_dir)1954BUG("entry->non_unqiue_dir not set and !new_path");1955output(o,1,_("CONFLICT (directory rename split): "1956"Unclear where to place%sbecause directory "1957"%swas renamed to multiple other directories, "1958"with no destination getting a majority of the "1959"files."),1960 path, entry->dir);1961 clean =0;1962return NULL;1963}19641965/*1966 * The caller needs to have ensured that it has pre-populated1967 * collisions with all paths that map to new_path. Do a quick check1968 * to ensure that's the case.1969 */1970 collision_ent =collision_find_entry(collisions, new_path);1971if(collision_ent == NULL)1972BUG("collision_ent is NULL");19731974/*1975 * Check for one-sided add/add/.../add conflicts, i.e.1976 * where implicit renames from the other side doing1977 * directory rename(s) can affect this side of history1978 * to put multiple paths into the same location. Warn1979 * and bail on directory renames for such paths.1980 */1981if(collision_ent->reported_already) {1982 clean =0;1983}else if(tree_has_path(tree, new_path)) {1984 collision_ent->reported_already =1;1985strbuf_add_separated_string_list(&collision_paths,", ",1986&collision_ent->source_files);1987output(o,1,_("CONFLICT (implicit dir rename): Existing "1988"file/dir at%sin the way of implicit "1989"directory rename(s) putting the following "1990"path(s) there:%s."),1991 new_path, collision_paths.buf);1992 clean =0;1993}else if(collision_ent->source_files.nr >1) {1994 collision_ent->reported_already =1;1995strbuf_add_separated_string_list(&collision_paths,", ",1996&collision_ent->source_files);1997output(o,1,_("CONFLICT (implicit dir rename): Cannot map "1998"more than one path to%s; implicit directory "1999"renames tried to put these paths there:%s"),2000 new_path, collision_paths.buf);2001 clean =0;2002}20032004/* Free memory we no longer need */2005strbuf_release(&collision_paths);2006if(!clean && new_path) {2007free(new_path);2008return NULL;2009}20102011return new_path;2012}20132014/*2015 * There are a couple things we want to do at the directory level:2016 * 1. Check for both sides renaming to the same thing, in order to avoid2017 * implicit renaming of files that should be left in place. (See2018 * testcase 6b in t6043 for details.)2019 * 2. Prune directory renames if there are still files left in the2020 * the original directory. These represent a partial directory rename,2021 * i.e. a rename where only some of the files within the directory2022 * were renamed elsewhere. (Technically, this could be done earlier2023 * in get_directory_renames(), except that would prevent us from2024 * doing the previous check and thus failing testcase 6b.)2025 * 3. Check for rename/rename(1to2) conflicts (at the directory level).2026 * In the future, we could potentially record this info as well and2027 * omit reporting rename/rename(1to2) conflicts for each path within2028 * the affected directories, thus cleaning up the merge output.2029 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the2030 * directory level, because merging directories is fine. If it2031 * causes conflicts for files within those merged directories, then2032 * that should be detected at the individual path level.2033 */2034static voidhandle_directory_level_conflicts(struct merge_options *o,2035struct hashmap *dir_re_head,2036struct tree *head,2037struct hashmap *dir_re_merge,2038struct tree *merge)2039{2040struct hashmap_iter iter;2041struct dir_rename_entry *head_ent;2042struct dir_rename_entry *merge_ent;20432044struct string_list remove_from_head = STRING_LIST_INIT_NODUP;2045struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;20462047hashmap_iter_init(dir_re_head, &iter);2048while((head_ent =hashmap_iter_next(&iter))) {2049 merge_ent =dir_rename_find_entry(dir_re_merge, head_ent->dir);2050if(merge_ent &&2051!head_ent->non_unique_new_dir &&2052!merge_ent->non_unique_new_dir &&2053!strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {2054/* 1. Renamed identically; remove it from both sides */2055string_list_append(&remove_from_head,2056 head_ent->dir)->util = head_ent;2057strbuf_release(&head_ent->new_dir);2058string_list_append(&remove_from_merge,2059 merge_ent->dir)->util = merge_ent;2060strbuf_release(&merge_ent->new_dir);2061}else if(tree_has_path(head, head_ent->dir)) {2062/* 2. This wasn't a directory rename after all */2063string_list_append(&remove_from_head,2064 head_ent->dir)->util = head_ent;2065strbuf_release(&head_ent->new_dir);2066}2067}20682069remove_hashmap_entries(dir_re_head, &remove_from_head);2070remove_hashmap_entries(dir_re_merge, &remove_from_merge);20712072hashmap_iter_init(dir_re_merge, &iter);2073while((merge_ent =hashmap_iter_next(&iter))) {2074 head_ent =dir_rename_find_entry(dir_re_head, merge_ent->dir);2075if(tree_has_path(merge, merge_ent->dir)) {2076/* 2. This wasn't a directory rename after all */2077string_list_append(&remove_from_merge,2078 merge_ent->dir)->util = merge_ent;2079}else if(head_ent &&2080!head_ent->non_unique_new_dir &&2081!merge_ent->non_unique_new_dir) {2082/* 3. rename/rename(1to2) */2083/*2084 * We can assume it's not rename/rename(1to1) because2085 * that was case (1), already checked above. So we2086 * know that head_ent->new_dir and merge_ent->new_dir2087 * are different strings.2088 */2089output(o,1,_("CONFLICT (rename/rename): "2090"Rename directory%s->%sin%s. "2091"Rename directory%s->%sin%s"),2092 head_ent->dir, head_ent->new_dir.buf, o->branch1,2093 head_ent->dir, merge_ent->new_dir.buf, o->branch2);2094string_list_append(&remove_from_head,2095 head_ent->dir)->util = head_ent;2096strbuf_release(&head_ent->new_dir);2097string_list_append(&remove_from_merge,2098 merge_ent->dir)->util = merge_ent;2099strbuf_release(&merge_ent->new_dir);2100}2101}21022103remove_hashmap_entries(dir_re_head, &remove_from_head);2104remove_hashmap_entries(dir_re_merge, &remove_from_merge);2105}21062107static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,2108struct tree *tree)2109{2110struct hashmap *dir_renames;2111struct hashmap_iter iter;2112struct dir_rename_entry *entry;2113int i;21142115/*2116 * Typically, we think of a directory rename as all files from a2117 * certain directory being moved to a target directory. However,2118 * what if someone first moved two files from the original2119 * directory in one commit, and then renamed the directory2120 * somewhere else in a later commit? At merge time, we just know2121 * that files from the original directory went to two different2122 * places, and that the bulk of them ended up in the same place.2123 * We want each directory rename to represent where the bulk of the2124 * files from that directory end up; this function exists to find2125 * where the bulk of the files went.2126 *2127 * The first loop below simply iterates through the list of file2128 * renames, finding out how often each directory rename pair2129 * possibility occurs.2130 */2131 dir_renames =xmalloc(sizeof(*dir_renames));2132dir_rename_init(dir_renames);2133for(i =0; i < pairs->nr; ++i) {2134struct string_list_item *item;2135int*count;2136struct diff_filepair *pair = pairs->queue[i];2137char*old_dir, *new_dir;21382139/* File not part of directory rename if it wasn't renamed */2140if(pair->status !='R')2141continue;21422143get_renamed_dir_portion(pair->one->path, pair->two->path,2144&old_dir, &new_dir);2145if(!old_dir)2146/* Directory didn't change at all; ignore this one. */2147continue;21482149 entry =dir_rename_find_entry(dir_renames, old_dir);2150if(!entry) {2151 entry =xmalloc(sizeof(*entry));2152dir_rename_entry_init(entry, old_dir);2153hashmap_put(dir_renames, entry);2154}else{2155free(old_dir);2156}2157 item =string_list_lookup(&entry->possible_new_dirs, new_dir);2158if(!item) {2159 item =string_list_insert(&entry->possible_new_dirs,2160 new_dir);2161 item->util =xcalloc(1,sizeof(int));2162}else{2163free(new_dir);2164}2165 count = item->util;2166*count +=1;2167}21682169/*2170 * For each directory with files moved out of it, we find out which2171 * target directory received the most files so we can declare it to2172 * be the "winning" target location for the directory rename. This2173 * winner gets recorded in new_dir. If there is no winner2174 * (multiple target directories received the same number of files),2175 * we set non_unique_new_dir. Once we've determined the winner (or2176 * that there is no winner), we no longer need possible_new_dirs.2177 */2178hashmap_iter_init(dir_renames, &iter);2179while((entry =hashmap_iter_next(&iter))) {2180int max =0;2181int bad_max =0;2182char*best = NULL;21832184for(i =0; i < entry->possible_new_dirs.nr; i++) {2185int*count = entry->possible_new_dirs.items[i].util;21862187if(*count == max)2188 bad_max = max;2189else if(*count > max) {2190 max = *count;2191 best = entry->possible_new_dirs.items[i].string;2192}2193}2194if(bad_max == max)2195 entry->non_unique_new_dir =1;2196else{2197assert(entry->new_dir.len ==0);2198strbuf_addstr(&entry->new_dir, best);2199}2200/*2201 * The relevant directory sub-portion of the original full2202 * filepaths were xstrndup'ed before inserting into2203 * possible_new_dirs, and instead of manually iterating the2204 * list and free'ing each, just lie and tell2205 * possible_new_dirs that it did the strdup'ing so that it2206 * will free them for us.2207 */2208 entry->possible_new_dirs.strdup_strings =1;2209string_list_clear(&entry->possible_new_dirs,1);2210}22112212return dir_renames;2213}22142215static struct dir_rename_entry *check_dir_renamed(const char*path,2216struct hashmap *dir_renames)2217{2218char*temp =xstrdup(path);2219char*end;2220struct dir_rename_entry *entry = NULL;;22212222while((end =strrchr(temp,'/'))) {2223*end ='\0';2224 entry =dir_rename_find_entry(dir_renames, temp);2225if(entry)2226break;2227}2228free(temp);2229return entry;2230}22312232static voidcompute_collisions(struct hashmap *collisions,2233struct hashmap *dir_renames,2234struct diff_queue_struct *pairs)2235{2236int i;22372238/*2239 * Multiple files can be mapped to the same path due to directory2240 * renames done by the other side of history. Since that other2241 * side of history could have merged multiple directories into one,2242 * if our side of history added the same file basename to each of2243 * those directories, then all N of them would get implicitly2244 * renamed by the directory rename detection into the same path,2245 * and we'd get an add/add/.../add conflict, and all those adds2246 * from *this* side of history. This is not representable in the2247 * index, and users aren't going to easily be able to make sense of2248 * it. So we need to provide a good warning about what's2249 * happening, and fall back to no-directory-rename detection2250 * behavior for those paths.2251 *2252 * See testcases 9e and all of section 5 from t6043 for examples.2253 */2254collision_init(collisions);22552256for(i =0; i < pairs->nr; ++i) {2257struct dir_rename_entry *dir_rename_ent;2258struct collision_entry *collision_ent;2259char*new_path;2260struct diff_filepair *pair = pairs->queue[i];22612262if(pair->status !='A'&& pair->status !='R')2263continue;2264 dir_rename_ent =check_dir_renamed(pair->two->path,2265 dir_renames);2266if(!dir_rename_ent)2267continue;22682269 new_path =apply_dir_rename(dir_rename_ent, pair->two->path);2270if(!new_path)2271/*2272 * dir_rename_ent->non_unique_new_path is true, which2273 * means there is no directory rename for us to use,2274 * which means it won't cause us any additional2275 * collisions.2276 */2277continue;2278 collision_ent =collision_find_entry(collisions, new_path);2279if(!collision_ent) {2280 collision_ent =xcalloc(1,2281sizeof(struct collision_entry));2282hashmap_entry_init(collision_ent,strhash(new_path));2283hashmap_put(collisions, collision_ent);2284 collision_ent->target_file = new_path;2285}else{2286free(new_path);2287}2288string_list_insert(&collision_ent->source_files,2289 pair->two->path);2290}2291}22922293static char*check_for_directory_rename(struct merge_options *o,2294const char*path,2295struct tree *tree,2296struct hashmap *dir_renames,2297struct hashmap *dir_rename_exclusions,2298struct hashmap *collisions,2299int*clean_merge)2300{2301char*new_path = NULL;2302struct dir_rename_entry *entry =check_dir_renamed(path, dir_renames);2303struct dir_rename_entry *oentry = NULL;23042305if(!entry)2306return new_path;23072308/*2309 * This next part is a little weird. We do not want to do an2310 * implicit rename into a directory we renamed on our side, because2311 * that will result in a spurious rename/rename(1to2) conflict. An2312 * example:2313 * Base commit: dumbdir/afile, otherdir/bfile2314 * Side 1: smrtdir/afile, otherdir/bfile2315 * Side 2: dumbdir/afile, dumbdir/bfile2316 * Here, while working on Side 1, we could notice that otherdir was2317 * renamed/merged to dumbdir, and change the diff_filepair for2318 * otherdir/bfile into a rename into dumbdir/bfile. However, Side2319 * 2 will notice the rename from dumbdir to smrtdir, and do the2320 * transitive rename to move it from dumbdir/bfile to2321 * smrtdir/bfile. That gives us bfile in dumbdir vs being in2322 * smrtdir, a rename/rename(1to2) conflict. We really just want2323 * the file to end up in smrtdir. And the way to achieve that is2324 * to not let Side1 do the rename to dumbdir, since we know that is2325 * the source of one of our directory renames.2326 *2327 * That's why oentry and dir_rename_exclusions is here.2328 *2329 * As it turns out, this also prevents N-way transient rename2330 * confusion; See testcases 9c and 9d of t6043.2331 */2332 oentry =dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);2333if(oentry) {2334output(o,1,_("WARNING: Avoiding applying%s->%srename "2335"to%s, because%sitself was renamed."),2336 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);2337}else{2338 new_path =handle_path_level_conflicts(o, path, entry,2339 collisions, tree);2340*clean_merge &= (new_path != NULL);2341}23422343return new_path;2344}23452346static voidapply_directory_rename_modifications(struct merge_options *o,2347struct diff_filepair *pair,2348char*new_path,2349struct rename *re,2350struct tree *tree,2351struct tree *o_tree,2352struct tree *a_tree,2353struct tree *b_tree,2354struct string_list *entries,2355int*clean)2356{2357struct string_list_item *item;2358int stage = (tree == a_tree ?2:3);2359int update_wd;23602361/*2362 * In all cases where we can do directory rename detection,2363 * unpack_trees() will have read pair->two->path into the2364 * index and the working copy. We need to remove it so that2365 * we can instead place it at new_path. It is guaranteed to2366 * not be untracked (unpack_trees() would have errored out2367 * saying the file would have been overwritten), but it might2368 * be dirty, though.2369 */2370 update_wd = !was_dirty(o, pair->two->path);2371if(!update_wd)2372output(o,1,_("Refusing to lose dirty file at%s"),2373 pair->two->path);2374remove_file(o,1, pair->two->path, !update_wd);23752376/* Find or create a new re->dst_entry */2377 item =string_list_lookup(entries, new_path);2378if(item) {2379/*2380 * Since we're renaming on this side of history, and it's2381 * due to a directory rename on the other side of history2382 * (which we only allow when the directory in question no2383 * longer exists on the other side of history), the2384 * original entry for re->dst_entry is no longer2385 * necessary...2386 */2387 re->dst_entry->processed =1;23882389/*2390 * ...because we'll be using this new one.2391 */2392 re->dst_entry = item->util;2393}else{2394/*2395 * re->dst_entry is for the before-dir-rename path, and we2396 * need it to hold information for the after-dir-rename2397 * path. Before creating a new entry, we need to mark the2398 * old one as unnecessary (...unless it is shared by2399 * src_entry, i.e. this didn't use to be a rename, in which2400 * case we can just allow the normal processing to happen2401 * for it).2402 */2403if(pair->status =='R')2404 re->dst_entry->processed =1;24052406 re->dst_entry =insert_stage_data(new_path,2407 o_tree, a_tree, b_tree,2408 entries);2409 item =string_list_insert(entries, new_path);2410 item->util = re->dst_entry;2411}24122413/*2414 * Update the stage_data with the information about the path we are2415 * moving into place. That slot will be empty and available for us2416 * to write to because of the collision checks in2417 * handle_path_level_conflicts(). In other words,2418 * re->dst_entry->stages[stage].oid will be the null_oid, so it's2419 * open for us to write to.2420 *2421 * It may be tempting to actually update the index at this point as2422 * well, using update_stages_for_stage_data(), but as per the big2423 * "NOTE" in update_stages(), doing so will modify the current2424 * in-memory index which will break calls to would_lose_untracked()2425 * that we need to make. Instead, we need to just make sure that2426 * the various conflict_rename_*() functions update the index2427 * explicitly rather than relying on unpack_trees() to have done it.2428 */2429get_tree_entry(&tree->object.oid,2430 pair->two->path,2431&re->dst_entry->stages[stage].oid,2432&re->dst_entry->stages[stage].mode);24332434/* Update pair status */2435if(pair->status =='A') {2436/*2437 * Recording rename information for this add makes it look2438 * like a rename/delete conflict. Make sure we can2439 * correctly handle this as an add that was moved to a new2440 * directory instead of reporting a rename/delete conflict.2441 */2442 re->add_turned_into_rename =1;2443}2444/*2445 * We don't actually look at pair->status again, but it seems2446 * pedagogically correct to adjust it.2447 */2448 pair->status ='R';24492450/*2451 * Finally, record the new location.2452 */2453 pair->two->path = new_path;2454}24552456/*2457 * Get information of all renames which occurred in 'pairs', making use of2458 * any implicit directory renames inferred from the other side of history.2459 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')2460 * to be able to associate the correct cache entries with the rename2461 * information; tree is always equal to either a_tree or b_tree.2462 */2463static struct string_list *get_renames(struct merge_options *o,2464struct diff_queue_struct *pairs,2465struct hashmap *dir_renames,2466struct hashmap *dir_rename_exclusions,2467struct tree *tree,2468struct tree *o_tree,2469struct tree *a_tree,2470struct tree *b_tree,2471struct string_list *entries,2472int*clean_merge)2473{2474int i;2475struct hashmap collisions;2476struct hashmap_iter iter;2477struct collision_entry *e;2478struct string_list *renames;24792480compute_collisions(&collisions, dir_renames, pairs);2481 renames =xcalloc(1,sizeof(struct string_list));24822483for(i =0; i < pairs->nr; ++i) {2484struct string_list_item *item;2485struct rename *re;2486struct diff_filepair *pair = pairs->queue[i];2487char*new_path;/* non-NULL only with directory renames */24882489if(pair->status !='A'&& pair->status !='R') {2490diff_free_filepair(pair);2491continue;2492}2493 new_path =check_for_directory_rename(o, pair->two->path, tree,2494 dir_renames,2495 dir_rename_exclusions,2496&collisions,2497 clean_merge);2498if(pair->status !='R'&& !new_path) {2499diff_free_filepair(pair);2500continue;2501}25022503 re =xmalloc(sizeof(*re));2504 re->processed =0;2505 re->add_turned_into_rename =0;2506 re->pair = pair;2507 item =string_list_lookup(entries, re->pair->one->path);2508if(!item)2509 re->src_entry =insert_stage_data(re->pair->one->path,2510 o_tree, a_tree, b_tree, entries);2511else2512 re->src_entry = item->util;25132514 item =string_list_lookup(entries, re->pair->two->path);2515if(!item)2516 re->dst_entry =insert_stage_data(re->pair->two->path,2517 o_tree, a_tree, b_tree, entries);2518else2519 re->dst_entry = item->util;2520 item =string_list_insert(renames, pair->one->path);2521 item->util = re;2522if(new_path)2523apply_directory_rename_modifications(o, pair, new_path,2524 re, tree, o_tree,2525 a_tree, b_tree,2526 entries,2527 clean_merge);2528}25292530hashmap_iter_init(&collisions, &iter);2531while((e =hashmap_iter_next(&iter))) {2532free(e->target_file);2533string_list_clear(&e->source_files,0);2534}2535hashmap_free(&collisions,1);2536return renames;2537}25382539static intprocess_renames(struct merge_options *o,2540struct string_list *a_renames,2541struct string_list *b_renames)2542{2543int clean_merge =1, i, j;2544struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2545struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2546const struct rename *sre;25472548for(i =0; i < a_renames->nr; i++) {2549 sre = a_renames->items[i].util;2550string_list_insert(&a_by_dst, sre->pair->two->path)->util2551= (void*)sre;2552}2553for(i =0; i < b_renames->nr; i++) {2554 sre = b_renames->items[i].util;2555string_list_insert(&b_by_dst, sre->pair->two->path)->util2556= (void*)sre;2557}25582559for(i =0, j =0; i < a_renames->nr || j < b_renames->nr;) {2560struct string_list *renames1, *renames2Dst;2561struct rename *ren1 = NULL, *ren2 = NULL;2562const char*branch1, *branch2;2563const char*ren1_src, *ren1_dst;2564struct string_list_item *lookup;25652566if(i >= a_renames->nr) {2567 ren2 = b_renames->items[j++].util;2568}else if(j >= b_renames->nr) {2569 ren1 = a_renames->items[i++].util;2570}else{2571int compare =strcmp(a_renames->items[i].string,2572 b_renames->items[j].string);2573if(compare <=0)2574 ren1 = a_renames->items[i++].util;2575if(compare >=0)2576 ren2 = b_renames->items[j++].util;2577}25782579/* TODO: refactor, so that 1/2 are not needed */2580if(ren1) {2581 renames1 = a_renames;2582 renames2Dst = &b_by_dst;2583 branch1 = o->branch1;2584 branch2 = o->branch2;2585}else{2586 renames1 = b_renames;2587 renames2Dst = &a_by_dst;2588 branch1 = o->branch2;2589 branch2 = o->branch1;2590SWAP(ren2, ren1);2591}25922593if(ren1->processed)2594continue;2595 ren1->processed =1;2596 ren1->dst_entry->processed =1;2597/* BUG: We should only mark src_entry as processed if we2598 * are not dealing with a rename + add-source case.2599 */2600 ren1->src_entry->processed =1;26012602 ren1_src = ren1->pair->one->path;2603 ren1_dst = ren1->pair->two->path;26042605if(ren2) {2606/* One file renamed on both sides */2607const char*ren2_src = ren2->pair->one->path;2608const char*ren2_dst = ren2->pair->two->path;2609enum rename_type rename_type;2610if(strcmp(ren1_src, ren2_src) !=0)2611BUG("ren1_src != ren2_src");2612 ren2->dst_entry->processed =1;2613 ren2->processed =1;2614if(strcmp(ren1_dst, ren2_dst) !=0) {2615 rename_type = RENAME_ONE_FILE_TO_TWO;2616 clean_merge =0;2617}else{2618 rename_type = RENAME_ONE_FILE_TO_ONE;2619/* BUG: We should only remove ren1_src in2620 * the base stage (think of rename +2621 * add-source cases).2622 */2623remove_file(o,1, ren1_src,1);2624update_entry(ren1->dst_entry,2625 ren1->pair->one,2626 ren1->pair->two,2627 ren2->pair->two);2628}2629setup_rename_conflict_info(rename_type,2630 ren1->pair,2631 ren2->pair,2632 branch1,2633 branch2,2634 ren1->dst_entry,2635 ren2->dst_entry,2636 o,2637 NULL,2638 NULL);2639}else if((lookup =string_list_lookup(renames2Dst, ren1_dst))) {2640/* Two different files renamed to the same thing */2641char*ren2_dst;2642 ren2 = lookup->util;2643 ren2_dst = ren2->pair->two->path;2644if(strcmp(ren1_dst, ren2_dst) !=0)2645BUG("ren1_dst != ren2_dst");26462647 clean_merge =0;2648 ren2->processed =1;2649/*2650 * BUG: We should only mark src_entry as processed2651 * if we are not dealing with a rename + add-source2652 * case.2653 */2654 ren2->src_entry->processed =1;26552656setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2657 ren1->pair,2658 ren2->pair,2659 branch1,2660 branch2,2661 ren1->dst_entry,2662 ren2->dst_entry,2663 o,2664 ren1->src_entry,2665 ren2->src_entry);26662667}else{2668/* Renamed in 1, maybe changed in 2 */2669/* we only use sha1 and mode of these */2670struct diff_filespec src_other, dst_other;2671int try_merge;26722673/*2674 * unpack_trees loads entries from common-commit2675 * into stage 1, from head-commit into stage 2, and2676 * from merge-commit into stage 3. We keep track2677 * of which side corresponds to the rename.2678 */2679int renamed_stage = a_renames == renames1 ?2:3;2680int other_stage = a_renames == renames1 ?3:2;26812682/* BUG: We should only remove ren1_src in the base2683 * stage and in other_stage (think of rename +2684 * add-source case).2685 */2686remove_file(o,1, ren1_src,2687 renamed_stage ==2|| !was_tracked(o, ren1_src));26882689oidcpy(&src_other.oid,2690&ren1->src_entry->stages[other_stage].oid);2691 src_other.mode = ren1->src_entry->stages[other_stage].mode;2692oidcpy(&dst_other.oid,2693&ren1->dst_entry->stages[other_stage].oid);2694 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2695 try_merge =0;26962697if(oid_eq(&src_other.oid, &null_oid) &&2698 ren1->add_turned_into_rename) {2699setup_rename_conflict_info(RENAME_DIR,2700 ren1->pair,2701 NULL,2702 branch1,2703 branch2,2704 ren1->dst_entry,2705 NULL,2706 o,2707 NULL,2708 NULL);2709}else if(oid_eq(&src_other.oid, &null_oid)) {2710setup_rename_conflict_info(RENAME_DELETE,2711 ren1->pair,2712 NULL,2713 branch1,2714 branch2,2715 ren1->dst_entry,2716 NULL,2717 o,2718 NULL,2719 NULL);2720}else if((dst_other.mode == ren1->pair->two->mode) &&2721oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2722/*2723 * Added file on the other side identical to2724 * the file being renamed: clean merge.2725 * Also, there is no need to overwrite the2726 * file already in the working copy, so call2727 * update_file_flags() instead of2728 * update_file().2729 */2730if(update_file_flags(o,2731&ren1->pair->two->oid,2732 ren1->pair->two->mode,2733 ren1_dst,27341,/* update_cache */27350/* update_wd */))2736 clean_merge = -1;2737}else if(!oid_eq(&dst_other.oid, &null_oid)) {2738 clean_merge =0;2739 try_merge =1;2740output(o,1,_("CONFLICT (rename/add): Rename%s->%sin%s. "2741"%sadded in%s"),2742 ren1_src, ren1_dst, branch1,2743 ren1_dst, branch2);2744if(o->call_depth) {2745struct merge_file_info mfi;2746if(merge_file_one(o, ren1_dst, &null_oid,0,2747&ren1->pair->two->oid,2748 ren1->pair->two->mode,2749&dst_other.oid,2750 dst_other.mode,2751 branch1, branch2, &mfi)) {2752 clean_merge = -1;2753goto cleanup_and_return;2754}2755output(o,1,_("Adding merged%s"), ren1_dst);2756if(update_file(o,0, &mfi.oid,2757 mfi.mode, ren1_dst))2758 clean_merge = -1;2759 try_merge =0;2760}else{2761char*new_path =unique_path(o, ren1_dst, branch2);2762output(o,1,_("Adding as%sinstead"), new_path);2763if(update_file(o,0, &dst_other.oid,2764 dst_other.mode, new_path))2765 clean_merge = -1;2766free(new_path);2767}2768}else2769 try_merge =1;27702771if(clean_merge <0)2772goto cleanup_and_return;2773if(try_merge) {2774struct diff_filespec *one, *a, *b;2775 src_other.path = (char*)ren1_src;27762777 one = ren1->pair->one;2778if(a_renames == renames1) {2779 a = ren1->pair->two;2780 b = &src_other;2781}else{2782 b = ren1->pair->two;2783 a = &src_other;2784}2785update_entry(ren1->dst_entry, one, a, b);2786setup_rename_conflict_info(RENAME_NORMAL,2787 ren1->pair,2788 NULL,2789 branch1,2790 NULL,2791 ren1->dst_entry,2792 NULL,2793 o,2794 NULL,2795 NULL);2796}2797}2798}2799cleanup_and_return:2800string_list_clear(&a_by_dst,0);2801string_list_clear(&b_by_dst,0);28022803return clean_merge;2804}28052806struct rename_info {2807struct string_list *head_renames;2808struct string_list *merge_renames;2809};28102811static voidinitial_cleanup_rename(struct diff_queue_struct *pairs,2812struct hashmap *dir_renames)2813{2814struct hashmap_iter iter;2815struct dir_rename_entry *e;28162817hashmap_iter_init(dir_renames, &iter);2818while((e =hashmap_iter_next(&iter))) {2819free(e->dir);2820strbuf_release(&e->new_dir);2821/* possible_new_dirs already cleared in get_directory_renames */2822}2823hashmap_free(dir_renames,1);2824free(dir_renames);28252826free(pairs->queue);2827free(pairs);2828}28292830static inthandle_renames(struct merge_options *o,2831struct tree *common,2832struct tree *head,2833struct tree *merge,2834struct string_list *entries,2835struct rename_info *ri)2836{2837struct diff_queue_struct *head_pairs, *merge_pairs;2838struct hashmap *dir_re_head, *dir_re_merge;2839int clean =1;28402841 ri->head_renames = NULL;2842 ri->merge_renames = NULL;28432844if(!merge_detect_rename(o))2845return1;28462847 head_pairs =get_diffpairs(o, common, head);2848 merge_pairs =get_diffpairs(o, common, merge);28492850 dir_re_head =get_directory_renames(head_pairs, head);2851 dir_re_merge =get_directory_renames(merge_pairs, merge);28522853handle_directory_level_conflicts(o,2854 dir_re_head, head,2855 dir_re_merge, merge);28562857 ri->head_renames =get_renames(o, head_pairs,2858 dir_re_merge, dir_re_head, head,2859 common, head, merge, entries,2860&clean);2861if(clean <0)2862goto cleanup;2863 ri->merge_renames =get_renames(o, merge_pairs,2864 dir_re_head, dir_re_merge, merge,2865 common, head, merge, entries,2866&clean);2867if(clean <0)2868goto cleanup;2869 clean &=process_renames(o, ri->head_renames, ri->merge_renames);28702871cleanup:2872/*2873 * Some cleanup is deferred until cleanup_renames() because the2874 * data structures are still needed and referenced in2875 * process_entry(). But there are a few things we can free now.2876 */2877initial_cleanup_rename(head_pairs, dir_re_head);2878initial_cleanup_rename(merge_pairs, dir_re_merge);28792880return clean;2881}28822883static voidfinal_cleanup_rename(struct string_list *rename)2884{2885const struct rename *re;2886int i;28872888if(rename == NULL)2889return;28902891for(i =0; i < rename->nr; i++) {2892 re = rename->items[i].util;2893diff_free_filepair(re->pair);2894}2895string_list_clear(rename,1);2896free(rename);2897}28982899static voidfinal_cleanup_renames(struct rename_info *re_info)2900{2901final_cleanup_rename(re_info->head_renames);2902final_cleanup_rename(re_info->merge_renames);2903}29042905static struct object_id *stage_oid(const struct object_id *oid,unsigned mode)2906{2907return(is_null_oid(oid) || mode ==0) ? NULL: (struct object_id *)oid;2908}29092910static intread_oid_strbuf(struct merge_options *o,2911const struct object_id *oid,struct strbuf *dst)2912{2913void*buf;2914enum object_type type;2915unsigned long size;2916 buf =read_object_file(oid, &type, &size);2917if(!buf)2918returnerr(o,_("cannot read object%s"),oid_to_hex(oid));2919if(type != OBJ_BLOB) {2920free(buf);2921returnerr(o,_("object%sis not a blob"),oid_to_hex(oid));2922}2923strbuf_attach(dst, buf, size, size +1);2924return0;2925}29262927static intblob_unchanged(struct merge_options *opt,2928const struct object_id *o_oid,2929unsigned o_mode,2930const struct object_id *a_oid,2931unsigned a_mode,2932int renormalize,const char*path)2933{2934struct strbuf o = STRBUF_INIT;2935struct strbuf a = STRBUF_INIT;2936int ret =0;/* assume changed for safety */29372938if(a_mode != o_mode)2939return0;2940if(oid_eq(o_oid, a_oid))2941return1;2942if(!renormalize)2943return0;29442945assert(o_oid && a_oid);2946if(read_oid_strbuf(opt, o_oid, &o) ||read_oid_strbuf(opt, a_oid, &a))2947goto error_return;2948/*2949 * Note: binary | is used so that both renormalizations are2950 * performed. Comparison can be skipped if both files are2951 * unchanged since their sha1s have already been compared.2952 */2953if(renormalize_buffer(&the_index, path, o.buf, o.len, &o) |2954renormalize_buffer(&the_index, path, a.buf, a.len, &a))2955 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));29562957error_return:2958strbuf_release(&o);2959strbuf_release(&a);2960return ret;2961}29622963static inthandle_modify_delete(struct merge_options *o,2964const char*path,2965struct object_id *o_oid,int o_mode,2966struct object_id *a_oid,int a_mode,2967struct object_id *b_oid,int b_mode)2968{2969const char*modify_branch, *delete_branch;2970struct object_id *changed_oid;2971int changed_mode;29722973if(a_oid) {2974 modify_branch = o->branch1;2975 delete_branch = o->branch2;2976 changed_oid = a_oid;2977 changed_mode = a_mode;2978}else{2979 modify_branch = o->branch2;2980 delete_branch = o->branch1;2981 changed_oid = b_oid;2982 changed_mode = b_mode;2983}29842985returnhandle_change_delete(o,2986 path, NULL,2987 o_oid, o_mode,2988 changed_oid, changed_mode,2989 modify_branch, delete_branch,2990_("modify"),_("modified"));2991}29922993static intmerge_content(struct merge_options *o,2994const char*path,2995int is_dirty,2996struct object_id *o_oid,int o_mode,2997struct object_id *a_oid,int a_mode,2998struct object_id *b_oid,int b_mode,2999struct rename_conflict_info *rename_conflict_info)3000{3001const char*reason =_("content");3002const char*path1 = NULL, *path2 = NULL;3003struct merge_file_info mfi;3004struct diff_filespec one, a, b;3005unsigned df_conflict_remains =0;30063007if(!o_oid) {3008 reason =_("add/add");3009 o_oid = (struct object_id *)&null_oid;3010}3011 one.path = a.path = b.path = (char*)path;3012oidcpy(&one.oid, o_oid);3013 one.mode = o_mode;3014oidcpy(&a.oid, a_oid);3015 a.mode = a_mode;3016oidcpy(&b.oid, b_oid);3017 b.mode = b_mode;30183019if(rename_conflict_info) {3020struct diff_filepair *pair1 = rename_conflict_info->pair1;30213022 path1 = (o->branch1 == rename_conflict_info->branch1) ?3023 pair1->two->path : pair1->one->path;3024/* If rename_conflict_info->pair2 != NULL, we are in3025 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a3026 * normal rename.3027 */3028 path2 = (rename_conflict_info->pair2 ||3029 o->branch2 == rename_conflict_info->branch1) ?3030 pair1->two->path : pair1->one->path;30313032if(dir_in_way(path, !o->call_depth,3033S_ISGITLINK(pair1->two->mode)))3034 df_conflict_remains =1;3035}3036if(merge_file_special_markers(o, &one, &a, &b, path,3037 o->branch1, path1,3038 o->branch2, path2, &mfi))3039return-1;30403041/*3042 * We can skip updating the working tree file iff:3043 * a) The merge is clean3044 * b) The merge matches what was in HEAD (content, mode, pathname)3045 * c) The target path is usable (i.e. not involved in D/F conflict)3046 */3047if(mfi.clean &&3048was_tracked_and_matches(o, path, &mfi.oid, mfi.mode) &&3049!df_conflict_remains) {3050output(o,3,_("Skipped%s(merged same as existing)"), path);3051if(add_cacheinfo(o, mfi.mode, &mfi.oid, path,30520, (!o->call_depth && !is_dirty),0))3053return-1;3054return mfi.clean;3055}30563057if(!mfi.clean) {3058if(S_ISGITLINK(mfi.mode))3059 reason =_("submodule");3060output(o,1,_("CONFLICT (%s): Merge conflict in%s"),3061 reason, path);3062if(rename_conflict_info && !df_conflict_remains)3063if(update_stages(o, path, &one, &a, &b))3064return-1;3065}30663067if(df_conflict_remains || is_dirty) {3068char*new_path;3069if(o->call_depth) {3070remove_file_from_cache(path);3071}else{3072if(!mfi.clean) {3073if(update_stages(o, path, &one, &a, &b))3074return-1;3075}else{3076int file_from_stage2 =was_tracked(o, path);3077struct diff_filespec merged;3078oidcpy(&merged.oid, &mfi.oid);3079 merged.mode = mfi.mode;30803081if(update_stages(o, path, NULL,3082 file_from_stage2 ? &merged : NULL,3083 file_from_stage2 ? NULL : &merged))3084return-1;3085}30863087}3088 new_path =unique_path(o, path, rename_conflict_info->branch1);3089if(is_dirty) {3090output(o,1,_("Refusing to lose dirty file at%s"),3091 path);3092}3093output(o,1,_("Adding as%sinstead"), new_path);3094if(update_file(o,0, &mfi.oid, mfi.mode, new_path)) {3095free(new_path);3096return-1;3097}3098free(new_path);3099 mfi.clean =0;3100}else if(update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))3101return-1;3102return!is_dirty && mfi.clean;3103}31043105static intconflict_rename_normal(struct merge_options *o,3106const char*path,3107struct object_id *o_oid,unsigned int o_mode,3108struct object_id *a_oid,unsigned int a_mode,3109struct object_id *b_oid,unsigned int b_mode,3110struct rename_conflict_info *ci)3111{3112/* Merge the content and write it out */3113returnmerge_content(o, path,was_dirty(o, path),3114 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3115 ci);3116}31173118/* Per entry merge function */3119static intprocess_entry(struct merge_options *o,3120const char*path,struct stage_data *entry)3121{3122int clean_merge =1;3123int normalize = o->renormalize;3124unsigned o_mode = entry->stages[1].mode;3125unsigned a_mode = entry->stages[2].mode;3126unsigned b_mode = entry->stages[3].mode;3127struct object_id *o_oid =stage_oid(&entry->stages[1].oid, o_mode);3128struct object_id *a_oid =stage_oid(&entry->stages[2].oid, a_mode);3129struct object_id *b_oid =stage_oid(&entry->stages[3].oid, b_mode);31303131 entry->processed =1;3132if(entry->rename_conflict_info) {3133struct rename_conflict_info *conflict_info = entry->rename_conflict_info;3134switch(conflict_info->rename_type) {3135case RENAME_NORMAL:3136case RENAME_ONE_FILE_TO_ONE:3137 clean_merge =conflict_rename_normal(o,3138 path,3139 o_oid, o_mode,3140 a_oid, a_mode,3141 b_oid, b_mode,3142 conflict_info);3143break;3144case RENAME_DIR:3145 clean_merge =1;3146if(conflict_rename_dir(o,3147 conflict_info->pair1,3148 conflict_info->branch1,3149 conflict_info->branch2))3150 clean_merge = -1;3151break;3152case RENAME_DELETE:3153 clean_merge =0;3154if(conflict_rename_delete(o,3155 conflict_info->pair1,3156 conflict_info->branch1,3157 conflict_info->branch2))3158 clean_merge = -1;3159break;3160case RENAME_ONE_FILE_TO_TWO:3161 clean_merge =0;3162if(conflict_rename_rename_1to2(o, conflict_info))3163 clean_merge = -1;3164break;3165case RENAME_TWO_FILES_TO_ONE:3166 clean_merge =0;3167if(conflict_rename_rename_2to1(o, conflict_info))3168 clean_merge = -1;3169break;3170default:3171 entry->processed =0;3172break;3173}3174}else if(o_oid && (!a_oid || !b_oid)) {3175/* Case A: Deleted in one */3176if((!a_oid && !b_oid) ||3177(!b_oid &&blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||3178(!a_oid &&blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {3179/* Deleted in both or deleted in one and3180 * unchanged in the other */3181if(a_oid)3182output(o,2,_("Removing%s"), path);3183/* do not touch working file if it did not exist */3184remove_file(o,1, path, !a_oid);3185}else{3186/* Modify/delete; deleted side may have put a directory in the way */3187 clean_merge =0;3188if(handle_modify_delete(o, path, o_oid, o_mode,3189 a_oid, a_mode, b_oid, b_mode))3190 clean_merge = -1;3191}3192}else if((!o_oid && a_oid && !b_oid) ||3193(!o_oid && !a_oid && b_oid)) {3194/* Case B: Added in one. */3195/* [nothing|directory] -> ([nothing|directory], file) */31963197const char*add_branch;3198const char*other_branch;3199unsigned mode;3200const struct object_id *oid;3201const char*conf;32023203if(a_oid) {3204 add_branch = o->branch1;3205 other_branch = o->branch2;3206 mode = a_mode;3207 oid = a_oid;3208 conf =_("file/directory");3209}else{3210 add_branch = o->branch2;3211 other_branch = o->branch1;3212 mode = b_mode;3213 oid = b_oid;3214 conf =_("directory/file");3215}3216if(dir_in_way(path,3217!o->call_depth && !S_ISGITLINK(a_mode),32180)) {3219char*new_path =unique_path(o, path, add_branch);3220 clean_merge =0;3221output(o,1,_("CONFLICT (%s): There is a directory with name%sin%s. "3222"Adding%sas%s"),3223 conf, path, other_branch, path, new_path);3224if(update_file(o,0, oid, mode, new_path))3225 clean_merge = -1;3226else if(o->call_depth)3227remove_file_from_cache(path);3228free(new_path);3229}else{3230output(o,2,_("Adding%s"), path);3231/* do not overwrite file if already present */3232if(update_file_flags(o, oid, mode, path,1, !a_oid))3233 clean_merge = -1;3234}3235}else if(a_oid && b_oid) {3236/* Case C: Added in both (check for same permissions) and */3237/* case D: Modified in both, but differently. */3238int is_dirty =0;/* unpack_trees would have bailed if dirty */3239 clean_merge =merge_content(o, path, is_dirty,3240 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3241 NULL);3242}else if(!o_oid && !a_oid && !b_oid) {3243/*3244 * this entry was deleted altogether. a_mode == 0 means3245 * we had that path and want to actively remove it.3246 */3247remove_file(o,1, path, !a_mode);3248}else3249BUG("fatal merge failure, shouldn't happen.");32503251return clean_merge;3252}32533254intmerge_trees(struct merge_options *o,3255struct tree *head,3256struct tree *merge,3257struct tree *common,3258struct tree **result)3259{3260int code, clean;32613262if(o->subtree_shift) {3263 merge =shift_tree_object(head, merge, o->subtree_shift);3264 common =shift_tree_object(head, common, o->subtree_shift);3265}32663267if(oid_eq(&common->object.oid, &merge->object.oid)) {3268struct strbuf sb = STRBUF_INIT;32693270if(!o->call_depth &&index_has_changes(&sb)) {3271err(o,_("Dirty index: cannot merge (dirty:%s)"),3272 sb.buf);3273return0;3274}3275output(o,0,_("Already up to date!"));3276*result = head;3277return1;3278}32793280 code =unpack_trees_start(o, common, head, merge);32813282if(code !=0) {3283if(show(o,4) || o->call_depth)3284err(o,_("merging of trees%sand%sfailed"),3285oid_to_hex(&head->object.oid),3286oid_to_hex(&merge->object.oid));3287unpack_trees_finish(o);3288return-1;3289}32903291if(unmerged_cache()) {3292struct string_list *entries;3293struct rename_info re_info;3294int i;3295/*3296 * Only need the hashmap while processing entries, so3297 * initialize it here and free it when we are done running3298 * through the entries. Keeping it in the merge_options as3299 * opposed to decaring a local hashmap is for convenience3300 * so that we don't have to pass it to around.3301 */3302hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL,512);3303get_files_dirs(o, head);3304get_files_dirs(o, merge);33053306 entries =get_unmerged();3307 clean =handle_renames(o, common, head, merge, entries,3308&re_info);3309record_df_conflict_files(o, entries);3310if(clean <0)3311goto cleanup;3312for(i = entries->nr-1;0<= i; i--) {3313const char*path = entries->items[i].string;3314struct stage_data *e = entries->items[i].util;3315if(!e->processed) {3316int ret =process_entry(o, path, e);3317if(!ret)3318 clean =0;3319else if(ret <0) {3320 clean = ret;3321goto cleanup;3322}3323}3324}3325for(i =0; i < entries->nr; i++) {3326struct stage_data *e = entries->items[i].util;3327if(!e->processed)3328BUG("unprocessed path???%s",3329 entries->items[i].string);3330}33313332cleanup:3333final_cleanup_renames(&re_info);33343335string_list_clear(entries,1);3336free(entries);33373338hashmap_free(&o->current_file_dir_set,1);33393340if(clean <0) {3341unpack_trees_finish(o);3342return clean;3343}3344}3345else3346 clean =1;33473348unpack_trees_finish(o);33493350if(o->call_depth && !(*result =write_tree_from_memory(o)))3351return-1;33523353return clean;3354}33553356static struct commit_list *reverse_commit_list(struct commit_list *list)3357{3358struct commit_list *next = NULL, *current, *backup;3359for(current = list; current; current = backup) {3360 backup = current->next;3361 current->next = next;3362 next = current;3363}3364return next;3365}33663367/*3368 * Merge the commits h1 and h2, return the resulting virtual3369 * commit object and a flag indicating the cleanness of the merge.3370 */3371intmerge_recursive(struct merge_options *o,3372struct commit *h1,3373struct commit *h2,3374struct commit_list *ca,3375struct commit **result)3376{3377struct commit_list *iter;3378struct commit *merged_common_ancestors;3379struct tree *mrtree;3380int clean;33813382if(show(o,4)) {3383output(o,4,_("Merging:"));3384output_commit_title(o, h1);3385output_commit_title(o, h2);3386}33873388if(!ca) {3389 ca =get_merge_bases(h1, h2);3390 ca =reverse_commit_list(ca);3391}33923393if(show(o,5)) {3394unsigned cnt =commit_list_count(ca);33953396output(o,5,Q_("found%ucommon ancestor:",3397"found%ucommon ancestors:", cnt), cnt);3398for(iter = ca; iter; iter = iter->next)3399output_commit_title(o, iter->item);3400}34013402 merged_common_ancestors =pop_commit(&ca);3403if(merged_common_ancestors == NULL) {3404/* if there is no common ancestor, use an empty tree */3405struct tree *tree;34063407 tree =lookup_tree(the_hash_algo->empty_tree);3408 merged_common_ancestors =make_virtual_commit(tree,"ancestor");3409}34103411for(iter = ca; iter; iter = iter->next) {3412const char*saved_b1, *saved_b2;3413 o->call_depth++;3414/*3415 * When the merge fails, the result contains files3416 * with conflict markers. The cleanness flag is3417 * ignored (unless indicating an error), it was never3418 * actually used, as result of merge_trees has always3419 * overwritten it: the committed "conflicts" were3420 * already resolved.3421 */3422discard_cache();3423 saved_b1 = o->branch1;3424 saved_b2 = o->branch2;3425 o->branch1 ="Temporary merge branch 1";3426 o->branch2 ="Temporary merge branch 2";3427if(merge_recursive(o, merged_common_ancestors, iter->item,3428 NULL, &merged_common_ancestors) <0)3429return-1;3430 o->branch1 = saved_b1;3431 o->branch2 = saved_b2;3432 o->call_depth--;34333434if(!merged_common_ancestors)3435returnerr(o,_("merge returned no commit"));3436}34373438discard_cache();3439if(!o->call_depth)3440read_cache();34413442 o->ancestor ="merged common ancestors";3443 clean =merge_trees(o,get_commit_tree(h1),get_commit_tree(h2),3444get_commit_tree(merged_common_ancestors),3445&mrtree);3446if(clean <0) {3447flush_output(o);3448return clean;3449}34503451if(o->call_depth) {3452*result =make_virtual_commit(mrtree,"merged tree");3453commit_list_insert(h1, &(*result)->parents);3454commit_list_insert(h2, &(*result)->parents->next);3455}3456flush_output(o);3457if(!o->call_depth && o->buffer_output <2)3458strbuf_release(&o->obuf);3459if(show(o,2))3460diff_warn_rename_limit("merge.renamelimit",3461 o->needed_rename_limit,0);3462return clean;3463}34643465static struct commit *get_ref(const struct object_id *oid,const char*name)3466{3467struct object *object;34683469 object =deref_tag(parse_object(oid), name,strlen(name));3470if(!object)3471return NULL;3472if(object->type == OBJ_TREE)3473returnmake_virtual_commit((struct tree*)object, name);3474if(object->type != OBJ_COMMIT)3475return NULL;3476if(parse_commit((struct commit *)object))3477return NULL;3478return(struct commit *)object;3479}34803481intmerge_recursive_generic(struct merge_options *o,3482const struct object_id *head,3483const struct object_id *merge,3484int num_base_list,3485const struct object_id **base_list,3486struct commit **result)3487{3488int clean;3489struct lock_file lock = LOCK_INIT;3490struct commit *head_commit =get_ref(head, o->branch1);3491struct commit *next_commit =get_ref(merge, o->branch2);3492struct commit_list *ca = NULL;34933494if(base_list) {3495int i;3496for(i =0; i < num_base_list; ++i) {3497struct commit *base;3498if(!(base =get_ref(base_list[i],oid_to_hex(base_list[i]))))3499returnerr(o,_("Could not parse object '%s'"),3500oid_to_hex(base_list[i]));3501commit_list_insert(base, &ca);3502}3503}35043505hold_locked_index(&lock, LOCK_DIE_ON_ERROR);3506 clean =merge_recursive(o, head_commit, next_commit, ca,3507 result);3508if(clean <0) {3509rollback_lock_file(&lock);3510return clean;3511}35123513if(write_locked_index(&the_index, &lock,3514 COMMIT_LOCK | SKIP_IF_UNCHANGED))3515returnerr(o,_("Unable to write index."));35163517return clean ?0:1;3518}35193520static voidmerge_recursive_config(struct merge_options *o)3521{3522char*value = NULL;3523git_config_get_int("merge.verbosity", &o->verbosity);3524git_config_get_int("diff.renamelimit", &o->diff_rename_limit);3525git_config_get_int("merge.renamelimit", &o->merge_rename_limit);3526if(!git_config_get_string("diff.renames", &value)) {3527 o->diff_detect_rename =git_config_rename("diff.renames", value);3528free(value);3529}3530if(!git_config_get_string("merge.renames", &value)) {3531 o->merge_detect_rename =git_config_rename("merge.renames", value);3532free(value);3533}3534git_config(git_xmerge_config, NULL);3535}35363537voidinit_merge_options(struct merge_options *o)3538{3539const char*merge_verbosity;3540memset(o,0,sizeof(struct merge_options));3541 o->verbosity =2;3542 o->buffer_output =1;3543 o->diff_rename_limit = -1;3544 o->merge_rename_limit = -1;3545 o->renormalize =0;3546 o->diff_detect_rename = -1;3547 o->merge_detect_rename = -1;3548merge_recursive_config(o);3549 merge_verbosity =getenv("GIT_MERGE_VERBOSITY");3550if(merge_verbosity)3551 o->verbosity =strtol(merge_verbosity, NULL,10);3552if(o->verbosity >=5)3553 o->buffer_output =0;3554strbuf_init(&o->obuf,0);3555string_list_init(&o->df_conflict_file_set,1);3556}35573558intparse_merge_opt(struct merge_options *o,const char*s)3559{3560const char*arg;35613562if(!s || !*s)3563return-1;3564if(!strcmp(s,"ours"))3565 o->recursive_variant = MERGE_RECURSIVE_OURS;3566else if(!strcmp(s,"theirs"))3567 o->recursive_variant = MERGE_RECURSIVE_THEIRS;3568else if(!strcmp(s,"subtree"))3569 o->subtree_shift ="";3570else if(skip_prefix(s,"subtree=", &arg))3571 o->subtree_shift = arg;3572else if(!strcmp(s,"patience"))3573 o->xdl_opts =DIFF_WITH_ALG(o, PATIENCE_DIFF);3574else if(!strcmp(s,"histogram"))3575 o->xdl_opts =DIFF_WITH_ALG(o, HISTOGRAM_DIFF);3576else if(skip_prefix(s,"diff-algorithm=", &arg)) {3577long value =parse_algorithm_value(arg);3578if(value <0)3579return-1;3580/* clear out previous settings */3581DIFF_XDL_CLR(o, NEED_MINIMAL);3582 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3583 o->xdl_opts |= value;3584}3585else if(!strcmp(s,"ignore-space-change"))3586DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);3587else if(!strcmp(s,"ignore-all-space"))3588DIFF_XDL_SET(o, IGNORE_WHITESPACE);3589else if(!strcmp(s,"ignore-space-at-eol"))3590DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);3591else if(!strcmp(s,"ignore-cr-at-eol"))3592DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);3593else if(!strcmp(s,"renormalize"))3594 o->renormalize =1;3595else if(!strcmp(s,"no-renormalize"))3596 o->renormalize =0;3597else if(!strcmp(s,"no-renames"))3598 o->merge_detect_rename =0;3599else if(!strcmp(s,"find-renames")) {3600 o->merge_detect_rename =1;3601 o->rename_score =0;3602}3603else if(skip_prefix(s,"find-renames=", &arg) ||3604skip_prefix(s,"rename-threshold=", &arg)) {3605if((o->rename_score =parse_rename_score(&arg)) == -1|| *arg !=0)3606return-1;3607 o->merge_detect_rename =1;3608}3609else3610return-1;3611return0;3612}