1/* 2 * Recursive Merge algorithm stolen from git-merge-recursive.py by 3 * Fredrik Kuivinen. 4 * The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006 5 */ 6#include"cache.h" 7#include"config.h" 8#include"advice.h" 9#include"lockfile.h" 10#include"cache-tree.h" 11#include"object-store.h" 12#include"repository.h" 13#include"commit.h" 14#include"blob.h" 15#include"builtin.h" 16#include"tree-walk.h" 17#include"diff.h" 18#include"diffcore.h" 19#include"tag.h" 20#include"alloc.h" 21#include"unpack-trees.h" 22#include"string-list.h" 23#include"xdiff-interface.h" 24#include"ll-merge.h" 25#include"attr.h" 26#include"merge-recursive.h" 27#include"dir.h" 28#include"submodule.h" 29#include"revision.h" 30#include"commit-reach.h" 31 32struct path_hashmap_entry { 33struct hashmap_entry e; 34char path[FLEX_ARRAY]; 35}; 36 37static intpath_hashmap_cmp(const void*cmp_data, 38const void*entry, 39const void*entry_or_key, 40const void*keydata) 41{ 42const struct path_hashmap_entry *a = entry; 43const struct path_hashmap_entry *b = entry_or_key; 44const char*key = keydata; 45 46if(ignore_case) 47returnstrcasecmp(a->path, key ? key : b->path); 48else 49returnstrcmp(a->path, key ? key : b->path); 50} 51 52static unsigned intpath_hash(const char*path) 53{ 54return ignore_case ?strihash(path) :strhash(path); 55} 56 57static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap, 58char*dir) 59{ 60struct dir_rename_entry key; 61 62if(dir == NULL) 63return NULL; 64hashmap_entry_init(&key,strhash(dir)); 65 key.dir = dir; 66returnhashmap_get(hashmap, &key, NULL); 67} 68 69static intdir_rename_cmp(const void*unused_cmp_data, 70const void*entry, 71const void*entry_or_key, 72const void*unused_keydata) 73{ 74const struct dir_rename_entry *e1 = entry; 75const struct dir_rename_entry *e2 = entry_or_key; 76 77returnstrcmp(e1->dir, e2->dir); 78} 79 80static voiddir_rename_init(struct hashmap *map) 81{ 82hashmap_init(map, dir_rename_cmp, NULL,0); 83} 84 85static voiddir_rename_entry_init(struct dir_rename_entry *entry, 86char*directory) 87{ 88hashmap_entry_init(entry,strhash(directory)); 89 entry->dir = directory; 90 entry->non_unique_new_dir =0; 91strbuf_init(&entry->new_dir,0); 92string_list_init(&entry->possible_new_dirs,0); 93} 94 95static struct collision_entry *collision_find_entry(struct hashmap *hashmap, 96char*target_file) 97{ 98struct collision_entry key; 99 100hashmap_entry_init(&key,strhash(target_file)); 101 key.target_file = target_file; 102returnhashmap_get(hashmap, &key, NULL); 103} 104 105static intcollision_cmp(void*unused_cmp_data, 106const struct collision_entry *e1, 107const struct collision_entry *e2, 108const void*unused_keydata) 109{ 110returnstrcmp(e1->target_file, e2->target_file); 111} 112 113static voidcollision_init(struct hashmap *map) 114{ 115hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL,0); 116} 117 118static voidflush_output(struct merge_options *o) 119{ 120if(o->buffer_output <2&& o->obuf.len) { 121fputs(o->obuf.buf, stdout); 122strbuf_reset(&o->obuf); 123} 124} 125 126static interr(struct merge_options *o,const char*err, ...) 127{ 128va_list params; 129 130if(o->buffer_output <2) 131flush_output(o); 132else{ 133strbuf_complete(&o->obuf,'\n'); 134strbuf_addstr(&o->obuf,"error: "); 135} 136va_start(params, err); 137strbuf_vaddf(&o->obuf, err, params); 138va_end(params); 139if(o->buffer_output >1) 140strbuf_addch(&o->obuf,'\n'); 141else{ 142error("%s", o->obuf.buf); 143strbuf_reset(&o->obuf); 144} 145 146return-1; 147} 148 149static struct tree *shift_tree_object(struct tree *one,struct tree *two, 150const char*subtree_shift) 151{ 152struct object_id shifted; 153 154if(!*subtree_shift) { 155shift_tree(&one->object.oid, &two->object.oid, &shifted,0); 156}else{ 157shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 158 subtree_shift); 159} 160if(oideq(&two->object.oid, &shifted)) 161return two; 162returnlookup_tree(the_repository, &shifted); 163} 164 165static struct commit *make_virtual_commit(struct tree *tree,const char*comment) 166{ 167struct commit *commit =alloc_commit_node(the_repository); 168 169set_merge_remote_desc(commit, comment, (struct object *)commit); 170 commit->maybe_tree = tree; 171 commit->object.parsed =1; 172return commit; 173} 174 175/* 176 * Since we use get_tree_entry(), which does not put the read object into 177 * the object pool, we cannot rely on a == b. 178 */ 179static intoid_eq(const struct object_id *a,const struct object_id *b) 180{ 181if(!a && !b) 182return2; 183return a && b &&oideq(a, b); 184} 185 186enum rename_type { 187 RENAME_NORMAL =0, 188 RENAME_VIA_DIR, 189 RENAME_DELETE, 190 RENAME_ONE_FILE_TO_ONE, 191 RENAME_ONE_FILE_TO_TWO, 192 RENAME_TWO_FILES_TO_ONE 193}; 194 195struct rename_conflict_info { 196enum rename_type rename_type; 197struct diff_filepair *pair1; 198struct diff_filepair *pair2; 199const char*branch1; 200const char*branch2; 201struct stage_data *dst_entry1; 202struct stage_data *dst_entry2; 203struct diff_filespec ren1_other; 204struct diff_filespec ren2_other; 205}; 206 207/* 208 * Since we want to write the index eventually, we cannot reuse the index 209 * for these (temporary) data. 210 */ 211struct stage_data { 212struct{ 213unsigned mode; 214struct object_id oid; 215} stages[4]; 216struct rename_conflict_info *rename_conflict_info; 217unsigned processed:1; 218}; 219 220staticinlinevoidsetup_rename_conflict_info(enum rename_type rename_type, 221struct diff_filepair *pair1, 222struct diff_filepair *pair2, 223const char*branch1, 224const char*branch2, 225struct stage_data *dst_entry1, 226struct stage_data *dst_entry2, 227struct merge_options *o, 228struct stage_data *src_entry1, 229struct stage_data *src_entry2) 230{ 231struct rename_conflict_info *ci =xcalloc(1,sizeof(struct rename_conflict_info)); 232 ci->rename_type = rename_type; 233 ci->pair1 = pair1; 234 ci->branch1 = branch1; 235 ci->branch2 = branch2; 236 237 ci->dst_entry1 = dst_entry1; 238 dst_entry1->rename_conflict_info = ci; 239 dst_entry1->processed =0; 240 241assert(!pair2 == !dst_entry2); 242if(dst_entry2) { 243 ci->dst_entry2 = dst_entry2; 244 ci->pair2 = pair2; 245 dst_entry2->rename_conflict_info = ci; 246} 247 248if(rename_type == RENAME_TWO_FILES_TO_ONE) { 249/* 250 * For each rename, there could have been 251 * modifications on the side of history where that 252 * file was not renamed. 253 */ 254int ostage1 = o->branch1 == branch1 ?3:2; 255int ostage2 = ostage1 ^1; 256 257 ci->ren1_other.path = pair1->one->path; 258oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid); 259 ci->ren1_other.mode = src_entry1->stages[ostage1].mode; 260 261 ci->ren2_other.path = pair2->one->path; 262oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid); 263 ci->ren2_other.mode = src_entry2->stages[ostage2].mode; 264} 265} 266 267static intshow(struct merge_options *o,int v) 268{ 269return(!o->call_depth && o->verbosity >= v) || o->verbosity >=5; 270} 271 272__attribute__((format(printf,3,4))) 273static voidoutput(struct merge_options *o,int v,const char*fmt, ...) 274{ 275va_list ap; 276 277if(!show(o, v)) 278return; 279 280strbuf_addchars(&o->obuf,' ', o->call_depth *2); 281 282va_start(ap, fmt); 283strbuf_vaddf(&o->obuf, fmt, ap); 284va_end(ap); 285 286strbuf_addch(&o->obuf,'\n'); 287if(!o->buffer_output) 288flush_output(o); 289} 290 291static voidoutput_commit_title(struct merge_options *o,struct commit *commit) 292{ 293struct merge_remote_desc *desc; 294 295strbuf_addchars(&o->obuf,' ', o->call_depth *2); 296 desc =merge_remote_util(commit); 297if(desc) 298strbuf_addf(&o->obuf,"virtual%s\n", desc->name); 299else{ 300strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid, 301 DEFAULT_ABBREV); 302strbuf_addch(&o->obuf,' '); 303if(parse_commit(commit) !=0) 304strbuf_addstr(&o->obuf,_("(bad commit)\n")); 305else{ 306const char*title; 307const char*msg =get_commit_buffer(commit, NULL); 308int len =find_commit_subject(msg, &title); 309if(len) 310strbuf_addf(&o->obuf,"%.*s\n", len, title); 311unuse_commit_buffer(commit, msg); 312} 313} 314flush_output(o); 315} 316 317static intadd_cacheinfo(struct merge_options *o, 318unsigned int mode,const struct object_id *oid, 319const char*path,int stage,int refresh,int options) 320{ 321struct cache_entry *ce; 322int ret; 323 324 ce =make_cache_entry(&the_index, mode, oid ? oid : &null_oid, path, stage,0); 325if(!ce) 326returnerr(o,_("add_cacheinfo failed for path '%s'; merge aborting."), path); 327 328 ret =add_cache_entry(ce, options); 329if(refresh) { 330struct cache_entry *nce; 331 332 nce =refresh_cache_entry(&the_index, ce, CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 333if(!nce) 334returnerr(o,_("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); 335if(nce != ce) 336 ret =add_cache_entry(nce, options); 337} 338return ret; 339} 340 341static voidinit_tree_desc_from_tree(struct tree_desc *desc,struct tree *tree) 342{ 343parse_tree(tree); 344init_tree_desc(desc, tree->buffer, tree->size); 345} 346 347static intunpack_trees_start(struct merge_options *o, 348struct tree *common, 349struct tree *head, 350struct tree *merge) 351{ 352int rc; 353struct tree_desc t[3]; 354struct index_state tmp_index = { NULL }; 355 356memset(&o->unpack_opts,0,sizeof(o->unpack_opts)); 357if(o->call_depth) 358 o->unpack_opts.index_only =1; 359else 360 o->unpack_opts.update =1; 361 o->unpack_opts.merge =1; 362 o->unpack_opts.head_idx =2; 363 o->unpack_opts.fn = threeway_merge; 364 o->unpack_opts.src_index = &the_index; 365 o->unpack_opts.dst_index = &tmp_index; 366 o->unpack_opts.aggressive = !merge_detect_rename(o); 367setup_unpack_trees_porcelain(&o->unpack_opts,"merge"); 368 369init_tree_desc_from_tree(t+0, common); 370init_tree_desc_from_tree(t+1, head); 371init_tree_desc_from_tree(t+2, merge); 372 373 rc =unpack_trees(3, t, &o->unpack_opts); 374cache_tree_free(&active_cache_tree); 375 376/* 377 * Update the_index to match the new results, AFTER saving a copy 378 * in o->orig_index. Update src_index to point to the saved copy. 379 * (verify_uptodate() checks src_index, and the original index is 380 * the one that had the necessary modification timestamps.) 381 */ 382 o->orig_index = the_index; 383 the_index = tmp_index; 384 o->unpack_opts.src_index = &o->orig_index; 385 386return rc; 387} 388 389static voidunpack_trees_finish(struct merge_options *o) 390{ 391discard_index(&o->orig_index); 392clear_unpack_trees_porcelain(&o->unpack_opts); 393} 394 395struct tree *write_tree_from_memory(struct merge_options *o) 396{ 397struct tree *result = NULL; 398 399if(unmerged_cache()) { 400int i; 401fprintf(stderr,"BUG: There are unmerged index entries:\n"); 402for(i =0; i < active_nr; i++) { 403const struct cache_entry *ce = active_cache[i]; 404if(ce_stage(ce)) 405fprintf(stderr,"BUG:%d%.*s\n",ce_stage(ce), 406(int)ce_namelen(ce), ce->name); 407} 408BUG("unmerged index entries in merge-recursive.c"); 409} 410 411if(!active_cache_tree) 412 active_cache_tree =cache_tree(); 413 414if(!cache_tree_fully_valid(active_cache_tree) && 415cache_tree_update(&the_index,0) <0) { 416err(o,_("error building trees")); 417return NULL; 418} 419 420 result =lookup_tree(the_repository, &active_cache_tree->oid); 421 422return result; 423} 424 425static intsave_files_dirs(const struct object_id *oid, 426struct strbuf *base,const char*path, 427unsigned int mode,int stage,void*context) 428{ 429struct path_hashmap_entry *entry; 430int baselen = base->len; 431struct merge_options *o = context; 432 433strbuf_addstr(base, path); 434 435FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 436hashmap_entry_init(entry,path_hash(entry->path)); 437hashmap_add(&o->current_file_dir_set, entry); 438 439strbuf_setlen(base, baselen); 440return(S_ISDIR(mode) ? READ_TREE_RECURSIVE :0); 441} 442 443static voidget_files_dirs(struct merge_options *o,struct tree *tree) 444{ 445struct pathspec match_all; 446memset(&match_all,0,sizeof(match_all)); 447read_tree_recursive(tree,"",0,0, &match_all, save_files_dirs, o); 448} 449 450static intget_tree_entry_if_blob(const struct object_id *tree, 451const char*path, 452struct object_id *hashy, 453unsigned int*mode_o) 454{ 455int ret; 456 457 ret =get_tree_entry(tree, path, hashy, mode_o); 458if(S_ISDIR(*mode_o)) { 459oidcpy(hashy, &null_oid); 460*mode_o =0; 461} 462return ret; 463} 464 465/* 466 * Returns an index_entry instance which doesn't have to correspond to 467 * a real cache entry in Git's index. 468 */ 469static struct stage_data *insert_stage_data(const char*path, 470struct tree *o,struct tree *a,struct tree *b, 471struct string_list *entries) 472{ 473struct string_list_item *item; 474struct stage_data *e =xcalloc(1,sizeof(struct stage_data)); 475get_tree_entry_if_blob(&o->object.oid, path, 476&e->stages[1].oid, &e->stages[1].mode); 477get_tree_entry_if_blob(&a->object.oid, path, 478&e->stages[2].oid, &e->stages[2].mode); 479get_tree_entry_if_blob(&b->object.oid, path, 480&e->stages[3].oid, &e->stages[3].mode); 481 item =string_list_insert(entries, path); 482 item->util = e; 483return e; 484} 485 486/* 487 * Create a dictionary mapping file names to stage_data objects. The 488 * dictionary contains one entry for every path with a non-zero stage entry. 489 */ 490static struct string_list *get_unmerged(void) 491{ 492struct string_list *unmerged =xcalloc(1,sizeof(struct string_list)); 493int i; 494 495 unmerged->strdup_strings =1; 496 497for(i =0; i < active_nr; i++) { 498struct string_list_item *item; 499struct stage_data *e; 500const struct cache_entry *ce = active_cache[i]; 501if(!ce_stage(ce)) 502continue; 503 504 item =string_list_lookup(unmerged, ce->name); 505if(!item) { 506 item =string_list_insert(unmerged, ce->name); 507 item->util =xcalloc(1,sizeof(struct stage_data)); 508} 509 e = item->util; 510 e->stages[ce_stage(ce)].mode = ce->ce_mode; 511oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 512} 513 514return unmerged; 515} 516 517static intstring_list_df_name_compare(const char*one,const char*two) 518{ 519int onelen =strlen(one); 520int twolen =strlen(two); 521/* 522 * Here we only care that entries for D/F conflicts are 523 * adjacent, in particular with the file of the D/F conflict 524 * appearing before files below the corresponding directory. 525 * The order of the rest of the list is irrelevant for us. 526 * 527 * To achieve this, we sort with df_name_compare and provide 528 * the mode S_IFDIR so that D/F conflicts will sort correctly. 529 * We use the mode S_IFDIR for everything else for simplicity, 530 * since in other cases any changes in their order due to 531 * sorting cause no problems for us. 532 */ 533int cmp =df_name_compare(one, onelen, S_IFDIR, 534 two, twolen, S_IFDIR); 535/* 536 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 537 * that 'foo' comes before 'foo/bar'. 538 */ 539if(cmp) 540return cmp; 541return onelen - twolen; 542} 543 544static voidrecord_df_conflict_files(struct merge_options *o, 545struct string_list *entries) 546{ 547/* If there is a D/F conflict and the file for such a conflict 548 * currently exists in the working tree, we want to allow it to be 549 * removed to make room for the corresponding directory if needed. 550 * The files underneath the directories of such D/F conflicts will 551 * be processed before the corresponding file involved in the D/F 552 * conflict. If the D/F directory ends up being removed by the 553 * merge, then we won't have to touch the D/F file. If the D/F 554 * directory needs to be written to the working copy, then the D/F 555 * file will simply be removed (in make_room_for_path()) to make 556 * room for the necessary paths. Note that if both the directory 557 * and the file need to be present, then the D/F file will be 558 * reinstated with a new unique name at the time it is processed. 559 */ 560struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 561const char*last_file = NULL; 562int last_len =0; 563int i; 564 565/* 566 * If we're merging merge-bases, we don't want to bother with 567 * any working directory changes. 568 */ 569if(o->call_depth) 570return; 571 572/* Ensure D/F conflicts are adjacent in the entries list. */ 573for(i =0; i < entries->nr; i++) { 574struct string_list_item *next = &entries->items[i]; 575string_list_append(&df_sorted_entries, next->string)->util = 576 next->util; 577} 578 df_sorted_entries.cmp = string_list_df_name_compare; 579string_list_sort(&df_sorted_entries); 580 581string_list_clear(&o->df_conflict_file_set,1); 582for(i =0; i < df_sorted_entries.nr; i++) { 583const char*path = df_sorted_entries.items[i].string; 584int len =strlen(path); 585struct stage_data *e = df_sorted_entries.items[i].util; 586 587/* 588 * Check if last_file & path correspond to a D/F conflict; 589 * i.e. whether path is last_file+'/'+<something>. 590 * If so, record that it's okay to remove last_file to make 591 * room for path and friends if needed. 592 */ 593if(last_file && 594 len > last_len && 595memcmp(path, last_file, last_len) ==0&& 596 path[last_len] =='/') { 597string_list_insert(&o->df_conflict_file_set, last_file); 598} 599 600/* 601 * Determine whether path could exist as a file in the 602 * working directory as a possible D/F conflict. This 603 * will only occur when it exists in stage 2 as a 604 * file. 605 */ 606if(S_ISREG(e->stages[2].mode) ||S_ISLNK(e->stages[2].mode)) { 607 last_file = path; 608 last_len = len; 609}else{ 610 last_file = NULL; 611} 612} 613string_list_clear(&df_sorted_entries,0); 614} 615 616struct rename { 617struct diff_filepair *pair; 618/* 619 * Purpose of src_entry and dst_entry: 620 * 621 * If 'before' is renamed to 'after' then src_entry will contain 622 * the versions of 'before' from the merge_base, HEAD, and MERGE in 623 * stages 1, 2, and 3; dst_entry will contain the respective 624 * versions of 'after' in corresponding locations. Thus, we have a 625 * total of six modes and oids, though some will be null. (Stage 0 626 * is ignored; we're interested in handling conflicts.) 627 * 628 * Since we don't turn on break-rewrites by default, neither 629 * src_entry nor dst_entry can have all three of their stages have 630 * non-null oids, meaning at most four of the six will be non-null. 631 * Also, since this is a rename, both src_entry and dst_entry will 632 * have at least one non-null oid, meaning at least two will be 633 * non-null. Of the six oids, a typical rename will have three be 634 * non-null. Only two implies a rename/delete, and four implies a 635 * rename/add. 636 */ 637struct stage_data *src_entry; 638struct stage_data *dst_entry; 639unsigned add_turned_into_rename:1; 640unsigned processed:1; 641}; 642 643static intupdate_stages(struct merge_options *opt,const char*path, 644const struct diff_filespec *o, 645const struct diff_filespec *a, 646const struct diff_filespec *b) 647{ 648 649/* 650 * NOTE: It is usually a bad idea to call update_stages on a path 651 * before calling update_file on that same path, since it can 652 * sometimes lead to spurious "refusing to lose untracked file..." 653 * messages from update_file (via make_room_for path via 654 * would_lose_untracked). Instead, reverse the order of the calls 655 * (executing update_file first and then update_stages). 656 */ 657int clear =1; 658int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 659if(clear) 660if(remove_file_from_cache(path)) 661return-1; 662if(o) 663if(add_cacheinfo(opt, o->mode, &o->oid, path,1,0, options)) 664return-1; 665if(a) 666if(add_cacheinfo(opt, a->mode, &a->oid, path,2,0, options)) 667return-1; 668if(b) 669if(add_cacheinfo(opt, b->mode, &b->oid, path,3,0, options)) 670return-1; 671return0; 672} 673 674static intupdate_stages_for_stage_data(struct merge_options *opt, 675const char*path, 676const struct stage_data *stage_data) 677{ 678struct diff_filespec o, a, b; 679 680 o.mode = stage_data->stages[1].mode; 681oidcpy(&o.oid, &stage_data->stages[1].oid); 682 683 a.mode = stage_data->stages[2].mode; 684oidcpy(&a.oid, &stage_data->stages[2].oid); 685 686 b.mode = stage_data->stages[3].mode; 687oidcpy(&b.oid, &stage_data->stages[3].oid); 688 689returnupdate_stages(opt, path, 690is_null_oid(&o.oid) ? NULL : &o, 691is_null_oid(&a.oid) ? NULL : &a, 692is_null_oid(&b.oid) ? NULL : &b); 693} 694 695static voidupdate_entry(struct stage_data *entry, 696struct diff_filespec *o, 697struct diff_filespec *a, 698struct diff_filespec *b) 699{ 700 entry->processed =0; 701 entry->stages[1].mode = o->mode; 702 entry->stages[2].mode = a->mode; 703 entry->stages[3].mode = b->mode; 704oidcpy(&entry->stages[1].oid, &o->oid); 705oidcpy(&entry->stages[2].oid, &a->oid); 706oidcpy(&entry->stages[3].oid, &b->oid); 707} 708 709static intremove_file(struct merge_options *o,int clean, 710const char*path,int no_wd) 711{ 712int update_cache = o->call_depth || clean; 713int update_working_directory = !o->call_depth && !no_wd; 714 715if(update_cache) { 716if(remove_file_from_cache(path)) 717return-1; 718} 719if(update_working_directory) { 720if(ignore_case) { 721struct cache_entry *ce; 722 ce =cache_file_exists(path,strlen(path), ignore_case); 723if(ce &&ce_stage(ce) ==0&&strcmp(path, ce->name)) 724return0; 725} 726if(remove_path(path)) 727return-1; 728} 729return0; 730} 731 732/* add a string to a strbuf, but converting "/" to "_" */ 733static voidadd_flattened_path(struct strbuf *out,const char*s) 734{ 735size_t i = out->len; 736strbuf_addstr(out, s); 737for(; i < out->len; i++) 738if(out->buf[i] =='/') 739 out->buf[i] ='_'; 740} 741 742static char*unique_path(struct merge_options *o,const char*path,const char*branch) 743{ 744struct path_hashmap_entry *entry; 745struct strbuf newpath = STRBUF_INIT; 746int suffix =0; 747size_t base_len; 748 749strbuf_addf(&newpath,"%s~", path); 750add_flattened_path(&newpath, branch); 751 752 base_len = newpath.len; 753while(hashmap_get_from_hash(&o->current_file_dir_set, 754path_hash(newpath.buf), newpath.buf) || 755(!o->call_depth &&file_exists(newpath.buf))) { 756strbuf_setlen(&newpath, base_len); 757strbuf_addf(&newpath,"_%d", suffix++); 758} 759 760FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 761hashmap_entry_init(entry,path_hash(entry->path)); 762hashmap_add(&o->current_file_dir_set, entry); 763returnstrbuf_detach(&newpath, NULL); 764} 765 766/** 767 * Check whether a directory in the index is in the way of an incoming 768 * file. Return 1 if so. If check_working_copy is non-zero, also 769 * check the working directory. If empty_ok is non-zero, also return 770 * 0 in the case where the working-tree dir exists but is empty. 771 */ 772static intdir_in_way(const char*path,int check_working_copy,int empty_ok) 773{ 774int pos; 775struct strbuf dirpath = STRBUF_INIT; 776struct stat st; 777 778strbuf_addstr(&dirpath, path); 779strbuf_addch(&dirpath,'/'); 780 781 pos =cache_name_pos(dirpath.buf, dirpath.len); 782 783if(pos <0) 784 pos = -1- pos; 785if(pos < active_nr && 786!strncmp(dirpath.buf, active_cache[pos]->name, dirpath.len)) { 787strbuf_release(&dirpath); 788return1; 789} 790 791strbuf_release(&dirpath); 792return check_working_copy && !lstat(path, &st) &&S_ISDIR(st.st_mode) && 793!(empty_ok &&is_empty_dir(path)); 794} 795 796/* 797 * Returns whether path was tracked in the index before the merge started, 798 * and its oid and mode match the specified values 799 */ 800static intwas_tracked_and_matches(struct merge_options *o,const char*path, 801const struct object_id *oid,unsigned mode) 802{ 803int pos =index_name_pos(&o->orig_index, path,strlen(path)); 804struct cache_entry *ce; 805 806if(0> pos) 807/* we were not tracking this path before the merge */ 808return0; 809 810/* See if the file we were tracking before matches */ 811 ce = o->orig_index.cache[pos]; 812return(oid_eq(&ce->oid, oid) && ce->ce_mode == mode); 813} 814 815/* 816 * Returns whether path was tracked in the index before the merge started 817 */ 818static intwas_tracked(struct merge_options *o,const char*path) 819{ 820int pos =index_name_pos(&o->orig_index, path,strlen(path)); 821 822if(0<= pos) 823/* we were tracking this path before the merge */ 824return1; 825 826return0; 827} 828 829static intwould_lose_untracked(const char*path) 830{ 831/* 832 * This may look like it can be simplified to: 833 * return !was_tracked(o, path) && file_exists(path) 834 * but it can't. This function needs to know whether path was in 835 * the working tree due to EITHER having been tracked in the index 836 * before the merge OR having been put into the working copy and 837 * index by unpack_trees(). Due to that either-or requirement, we 838 * check the current index instead of the original one. 839 * 840 * Note that we do not need to worry about merge-recursive itself 841 * updating the index after unpack_trees() and before calling this 842 * function, because we strictly require all code paths in 843 * merge-recursive to update the working tree first and the index 844 * second. Doing otherwise would break 845 * update_file()/would_lose_untracked(); see every comment in this 846 * file which mentions "update_stages". 847 */ 848int pos =cache_name_pos(path,strlen(path)); 849 850if(pos <0) 851 pos = -1- pos; 852while(pos < active_nr && 853!strcmp(path, active_cache[pos]->name)) { 854/* 855 * If stage #0, it is definitely tracked. 856 * If it has stage #2 then it was tracked 857 * before this merge started. All other 858 * cases the path was not tracked. 859 */ 860switch(ce_stage(active_cache[pos])) { 861case0: 862case2: 863return0; 864} 865 pos++; 866} 867returnfile_exists(path); 868} 869 870static intwas_dirty(struct merge_options *o,const char*path) 871{ 872struct cache_entry *ce; 873int dirty =1; 874 875if(o->call_depth || !was_tracked(o, path)) 876return!dirty; 877 878 ce =index_file_exists(o->unpack_opts.src_index, 879 path,strlen(path), ignore_case); 880 dirty =verify_uptodate(ce, &o->unpack_opts) !=0; 881return dirty; 882} 883 884static intmake_room_for_path(struct merge_options *o,const char*path) 885{ 886int status, i; 887const char*msg =_("failed to create path '%s'%s"); 888 889/* Unlink any D/F conflict files that are in the way */ 890for(i =0; i < o->df_conflict_file_set.nr; i++) { 891const char*df_path = o->df_conflict_file_set.items[i].string; 892size_t pathlen =strlen(path); 893size_t df_pathlen =strlen(df_path); 894if(df_pathlen < pathlen && 895 path[df_pathlen] =='/'&& 896strncmp(path, df_path, df_pathlen) ==0) { 897output(o,3, 898_("Removing%sto make room for subdirectory\n"), 899 df_path); 900unlink(df_path); 901unsorted_string_list_delete_item(&o->df_conflict_file_set, 902 i,0); 903break; 904} 905} 906 907/* Make sure leading directories are created */ 908 status =safe_create_leading_directories_const(path); 909if(status) { 910if(status == SCLD_EXISTS) 911/* something else exists */ 912returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 913returnerr(o, msg, path,""); 914} 915 916/* 917 * Do not unlink a file in the work tree if we are not 918 * tracking it. 919 */ 920if(would_lose_untracked(path)) 921returnerr(o,_("refusing to lose untracked file at '%s'"), 922 path); 923 924/* Successful unlink is good.. */ 925if(!unlink(path)) 926return0; 927/* .. and so is no existing file */ 928if(errno == ENOENT) 929return0; 930/* .. but not some other error (who really cares what?) */ 931returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 932} 933 934static intupdate_file_flags(struct merge_options *o, 935const struct object_id *oid, 936unsigned mode, 937const char*path, 938int update_cache, 939int update_wd) 940{ 941int ret =0; 942 943if(o->call_depth) 944 update_wd =0; 945 946if(update_wd) { 947enum object_type type; 948void*buf; 949unsigned long size; 950 951if(S_ISGITLINK(mode)) { 952/* 953 * We may later decide to recursively descend into 954 * the submodule directory and update its index 955 * and/or work tree, but we do not do that now. 956 */ 957 update_wd =0; 958goto update_index; 959} 960 961 buf =read_object_file(oid, &type, &size); 962if(!buf) 963returnerr(o,_("cannot read object%s'%s'"),oid_to_hex(oid), path); 964if(type != OBJ_BLOB) { 965 ret =err(o,_("blob expected for%s'%s'"),oid_to_hex(oid), path); 966goto free_buf; 967} 968if(S_ISREG(mode)) { 969struct strbuf strbuf = STRBUF_INIT; 970if(convert_to_working_tree(&the_index, path, buf, size, &strbuf)) { 971free(buf); 972 size = strbuf.len; 973 buf =strbuf_detach(&strbuf, NULL); 974} 975} 976 977if(make_room_for_path(o, path) <0) { 978 update_wd =0; 979goto free_buf; 980} 981if(S_ISREG(mode) || (!has_symlinks &&S_ISLNK(mode))) { 982int fd; 983if(mode &0100) 984 mode =0777; 985else 986 mode =0666; 987 fd =open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 988if(fd <0) { 989 ret =err(o,_("failed to open '%s':%s"), 990 path,strerror(errno)); 991goto free_buf; 992} 993write_in_full(fd, buf, size); 994close(fd); 995}else if(S_ISLNK(mode)) { 996char*lnk =xmemdupz(buf, size); 997safe_create_leading_directories_const(path); 998unlink(path); 999if(symlink(lnk, path))1000 ret =err(o,_("failed to symlink '%s':%s"),1001 path,strerror(errno));1002free(lnk);1003}else1004 ret =err(o,1005_("do not know what to do with%06o%s'%s'"),1006 mode,oid_to_hex(oid), path);1007 free_buf:1008free(buf);1009}1010update_index:1011if(!ret && update_cache)1012if(add_cacheinfo(o, mode, oid, path,0, update_wd,1013 ADD_CACHE_OK_TO_ADD))1014return-1;1015return ret;1016}10171018static intupdate_file(struct merge_options *o,1019int clean,1020const struct object_id *oid,1021unsigned mode,1022const char*path)1023{1024returnupdate_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth);1025}10261027/* Low level file merging, update and removal */10281029struct merge_file_info {1030struct object_id oid;1031unsigned mode;1032unsigned clean:1,1033 merge:1;1034};10351036static intmerge_3way(struct merge_options *o,1037 mmbuffer_t *result_buf,1038const struct diff_filespec *one,1039const struct diff_filespec *a,1040const struct diff_filespec *b,1041const char*branch1,1042const char*branch2)1043{1044 mmfile_t orig, src1, src2;1045struct ll_merge_options ll_opts = {0};1046char*base_name, *name1, *name2;1047int merge_status;10481049 ll_opts.renormalize = o->renormalize;1050 ll_opts.xdl_opts = o->xdl_opts;10511052if(o->call_depth) {1053 ll_opts.virtual_ancestor =1;1054 ll_opts.variant =0;1055}else{1056switch(o->recursive_variant) {1057case MERGE_RECURSIVE_OURS:1058 ll_opts.variant = XDL_MERGE_FAVOR_OURS;1059break;1060case MERGE_RECURSIVE_THEIRS:1061 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;1062break;1063default:1064 ll_opts.variant =0;1065break;1066}1067}10681069if(strcmp(a->path, b->path) ||1070(o->ancestor != NULL &&strcmp(a->path, one->path) !=0)) {1071 base_name = o->ancestor == NULL ? NULL :1072mkpathdup("%s:%s", o->ancestor, one->path);1073 name1 =mkpathdup("%s:%s", branch1, a->path);1074 name2 =mkpathdup("%s:%s", branch2, b->path);1075}else{1076 base_name = o->ancestor == NULL ? NULL :1077mkpathdup("%s", o->ancestor);1078 name1 =mkpathdup("%s", branch1);1079 name2 =mkpathdup("%s", branch2);1080}10811082read_mmblob(&orig, &one->oid);1083read_mmblob(&src1, &a->oid);1084read_mmblob(&src2, &b->oid);10851086 merge_status =ll_merge(result_buf, a->path, &orig, base_name,1087&src1, name1, &src2, name2, &ll_opts);10881089free(base_name);1090free(name1);1091free(name2);1092free(orig.ptr);1093free(src1.ptr);1094free(src2.ptr);1095return merge_status;1096}10971098static intfind_first_merges(struct object_array *result,const char*path,1099struct commit *a,struct commit *b)1100{1101int i, j;1102struct object_array merges = OBJECT_ARRAY_INIT;1103struct commit *commit;1104int contains_another;11051106char merged_revision[42];1107const char*rev_args[] = {"rev-list","--merges","--ancestry-path",1108"--all", merged_revision, NULL };1109struct rev_info revs;1110struct setup_revision_opt rev_opts;11111112memset(result,0,sizeof(struct object_array));1113memset(&rev_opts,0,sizeof(rev_opts));11141115/* get all revisions that merge commit a */1116xsnprintf(merged_revision,sizeof(merged_revision),"^%s",1117oid_to_hex(&a->object.oid));1118init_revisions(&revs, NULL);1119 rev_opts.submodule = path;1120/* FIXME: can't handle linked worktrees in submodules yet */1121 revs.single_worktree = path != NULL;1122setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);11231124/* save all revisions from the above list that contain b */1125if(prepare_revision_walk(&revs))1126die("revision walk setup failed");1127while((commit =get_revision(&revs)) != NULL) {1128struct object *o = &(commit->object);1129if(in_merge_bases(b, commit))1130add_object_array(o, NULL, &merges);1131}1132reset_revision_walk();11331134/* Now we've got all merges that contain a and b. Prune all1135 * merges that contain another found merge and save them in1136 * result.1137 */1138for(i =0; i < merges.nr; i++) {1139struct commit *m1 = (struct commit *) merges.objects[i].item;11401141 contains_another =0;1142for(j =0; j < merges.nr; j++) {1143struct commit *m2 = (struct commit *) merges.objects[j].item;1144if(i != j &&in_merge_bases(m2, m1)) {1145 contains_another =1;1146break;1147}1148}11491150if(!contains_another)1151add_object_array(merges.objects[i].item, NULL, result);1152}11531154object_array_clear(&merges);1155return result->nr;1156}11571158static voidprint_commit(struct commit *commit)1159{1160struct strbuf sb = STRBUF_INIT;1161struct pretty_print_context ctx = {0};1162 ctx.date_mode.type = DATE_NORMAL;1163format_commit_message(commit,"%h:%m %s", &sb, &ctx);1164fprintf(stderr,"%s\n", sb.buf);1165strbuf_release(&sb);1166}11671168static intmerge_submodule(struct merge_options *o,1169struct object_id *result,const char*path,1170const struct object_id *base,const struct object_id *a,1171const struct object_id *b)1172{1173struct commit *commit_base, *commit_a, *commit_b;1174int parent_count;1175struct object_array merges;11761177int i;1178int search = !o->call_depth;11791180/* store a in result in case we fail */1181oidcpy(result, a);11821183/* we can not handle deletion conflicts */1184if(is_null_oid(base))1185return0;1186if(is_null_oid(a))1187return0;1188if(is_null_oid(b))1189return0;11901191if(add_submodule_odb(path)) {1192output(o,1,_("Failed to merge submodule%s(not checked out)"), path);1193return0;1194}11951196if(!(commit_base =lookup_commit_reference(the_repository, base)) ||1197!(commit_a =lookup_commit_reference(the_repository, a)) ||1198!(commit_b =lookup_commit_reference(the_repository, b))) {1199output(o,1,_("Failed to merge submodule%s(commits not present)"), path);1200return0;1201}12021203/* check whether both changes are forward */1204if(!in_merge_bases(commit_base, commit_a) ||1205!in_merge_bases(commit_base, commit_b)) {1206output(o,1,_("Failed to merge submodule%s(commits don't follow merge-base)"), path);1207return0;1208}12091210/* Case #1: a is contained in b or vice versa */1211if(in_merge_bases(commit_a, commit_b)) {1212oidcpy(result, b);1213if(show(o,3)) {1214output(o,3,_("Fast-forwarding submodule%sto the following commit:"), path);1215output_commit_title(o, commit_b);1216}else if(show(o,2))1217output(o,2,_("Fast-forwarding submodule%s"), path);1218else1219;/* no output */12201221return1;1222}1223if(in_merge_bases(commit_b, commit_a)) {1224oidcpy(result, a);1225if(show(o,3)) {1226output(o,3,_("Fast-forwarding submodule%sto the following commit:"), path);1227output_commit_title(o, commit_a);1228}else if(show(o,2))1229output(o,2,_("Fast-forwarding submodule%s"), path);1230else1231;/* no output */12321233return1;1234}12351236/*1237 * Case #2: There are one or more merges that contain a and b in1238 * the submodule. If there is only one, then present it as a1239 * suggestion to the user, but leave it marked unmerged so the1240 * user needs to confirm the resolution.1241 */12421243/* Skip the search if makes no sense to the calling context. */1244if(!search)1245return0;12461247/* find commit which merges them */1248 parent_count =find_first_merges(&merges, path, commit_a, commit_b);1249switch(parent_count) {1250case0:1251output(o,1,_("Failed to merge submodule%s(merge following commits not found)"), path);1252break;12531254case1:1255output(o,1,_("Failed to merge submodule%s(not fast-forward)"), path);1256output(o,2,_("Found a possible merge resolution for the submodule:\n"));1257print_commit((struct commit *) merges.objects[0].item);1258output(o,2,_(1259"If this is correct simply add it to the index "1260"for example\n"1261"by using:\n\n"1262" git update-index --cacheinfo 160000%s\"%s\"\n\n"1263"which will accept this suggestion.\n"),1264oid_to_hex(&merges.objects[0].item->oid), path);1265break;12661267default:1268output(o,1,_("Failed to merge submodule%s(multiple merges found)"), path);1269for(i =0; i < merges.nr; i++)1270print_commit((struct commit *) merges.objects[i].item);1271}12721273object_array_clear(&merges);1274return0;1275}12761277static intmerge_mode_and_contents(struct merge_options *o,1278const struct diff_filespec *one,1279const struct diff_filespec *a,1280const struct diff_filespec *b,1281const char*filename,1282const char*branch1,1283const char*branch2,1284struct merge_file_info *result)1285{1286 result->merge =0;1287 result->clean =1;12881289if((S_IFMT & a->mode) != (S_IFMT & b->mode)) {1290 result->clean =0;1291if(S_ISREG(a->mode)) {1292 result->mode = a->mode;1293oidcpy(&result->oid, &a->oid);1294}else{1295 result->mode = b->mode;1296oidcpy(&result->oid, &b->oid);1297}1298}else{1299if(!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))1300 result->merge =1;13011302/*1303 * Merge modes1304 */1305if(a->mode == b->mode || a->mode == one->mode)1306 result->mode = b->mode;1307else{1308 result->mode = a->mode;1309if(b->mode != one->mode) {1310 result->clean =0;1311 result->merge =1;1312}1313}13141315if(oid_eq(&a->oid, &b->oid) ||oid_eq(&a->oid, &one->oid))1316oidcpy(&result->oid, &b->oid);1317else if(oid_eq(&b->oid, &one->oid))1318oidcpy(&result->oid, &a->oid);1319else if(S_ISREG(a->mode)) {1320 mmbuffer_t result_buf;1321int ret =0, merge_status;13221323 merge_status =merge_3way(o, &result_buf, one, a, b,1324 branch1, branch2);13251326if((merge_status <0) || !result_buf.ptr)1327 ret =err(o,_("Failed to execute internal merge"));13281329if(!ret &&1330write_object_file(result_buf.ptr, result_buf.size,1331 blob_type, &result->oid))1332 ret =err(o,_("Unable to add%sto database"),1333 a->path);13341335free(result_buf.ptr);1336if(ret)1337return ret;1338 result->clean = (merge_status ==0);1339}else if(S_ISGITLINK(a->mode)) {1340 result->clean =merge_submodule(o, &result->oid,1341 one->path,1342&one->oid,1343&a->oid,1344&b->oid);1345}else if(S_ISLNK(a->mode)) {1346switch(o->recursive_variant) {1347case MERGE_RECURSIVE_NORMAL:1348oidcpy(&result->oid, &a->oid);1349if(!oid_eq(&a->oid, &b->oid))1350 result->clean =0;1351break;1352case MERGE_RECURSIVE_OURS:1353oidcpy(&result->oid, &a->oid);1354break;1355case MERGE_RECURSIVE_THEIRS:1356oidcpy(&result->oid, &b->oid);1357break;1358}1359}else1360BUG("unsupported object type in the tree");1361}13621363if(result->merge)1364output(o,2,_("Auto-merging%s"), filename);13651366return0;1367}13681369static inthandle_rename_via_dir(struct merge_options *o,1370struct diff_filepair *pair,1371const char*rename_branch,1372const char*other_branch)1373{1374/*1375 * Handle file adds that need to be renamed due to directory rename1376 * detection. This differs from handle_rename_normal, because1377 * there is no content merge to do; just move the file into the1378 * desired final location.1379 */1380const struct diff_filespec *dest = pair->two;13811382if(!o->call_depth &&would_lose_untracked(dest->path)) {1383char*alt_path =unique_path(o, dest->path, rename_branch);13841385output(o,1,_("Error: Refusing to lose untracked file at%s; "1386"writing to%sinstead."),1387 dest->path, alt_path);1388/*1389 * Write the file in worktree at alt_path, but not in the1390 * index. Instead, write to dest->path for the index but1391 * only at the higher appropriate stage.1392 */1393if(update_file(o,0, &dest->oid, dest->mode, alt_path))1394return-1;1395free(alt_path);1396returnupdate_stages(o, dest->path, NULL,1397 rename_branch == o->branch1 ? dest : NULL,1398 rename_branch == o->branch1 ? NULL : dest);1399}14001401/* Update dest->path both in index and in worktree */1402if(update_file(o,1, &dest->oid, dest->mode, dest->path))1403return-1;1404return0;1405}14061407static inthandle_change_delete(struct merge_options *o,1408const char*path,const char*old_path,1409const struct object_id *o_oid,int o_mode,1410const struct object_id *changed_oid,1411int changed_mode,1412const char*change_branch,1413const char*delete_branch,1414const char*change,const char*change_past)1415{1416char*alt_path = NULL;1417const char*update_path = path;1418int ret =0;14191420if(dir_in_way(path, !o->call_depth,0) ||1421(!o->call_depth &&would_lose_untracked(path))) {1422 update_path = alt_path =unique_path(o, path, change_branch);1423}14241425if(o->call_depth) {1426/*1427 * We cannot arbitrarily accept either a_sha or b_sha as1428 * correct; since there is no true "middle point" between1429 * them, simply reuse the base version for virtual merge base.1430 */1431 ret =remove_file_from_cache(path);1432if(!ret)1433 ret =update_file(o,0, o_oid, o_mode, update_path);1434}else{1435/*1436 * Despite the four nearly duplicate messages and argument1437 * lists below and the ugliness of the nested if-statements,1438 * having complete messages makes the job easier for1439 * translators.1440 *1441 * The slight variance among the cases is due to the fact1442 * that:1443 * 1) directory/file conflicts (in effect if1444 * !alt_path) could cause us to need to write the1445 * file to a different path.1446 * 2) renames (in effect if !old_path) could mean that1447 * there are two names for the path that the user1448 * may know the file by.1449 */1450if(!alt_path) {1451if(!old_path) {1452output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1453"and%sin%s. Version%sof%sleft in tree."),1454 change, path, delete_branch, change_past,1455 change_branch, change_branch, path);1456}else{1457output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1458"and%sto%sin%s. Version%sof%sleft in tree."),1459 change, old_path, delete_branch, change_past, path,1460 change_branch, change_branch, path);1461}1462}else{1463if(!old_path) {1464output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1465"and%sin%s. Version%sof%sleft in tree at%s."),1466 change, path, delete_branch, change_past,1467 change_branch, change_branch, path, alt_path);1468}else{1469output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1470"and%sto%sin%s. Version%sof%sleft in tree at%s."),1471 change, old_path, delete_branch, change_past, path,1472 change_branch, change_branch, path, alt_path);1473}1474}1475/*1476 * No need to call update_file() on path when change_branch ==1477 * o->branch1 && !alt_path, since that would needlessly touch1478 * path. We could call update_file_flags() with update_cache=01479 * and update_wd=0, but that's a no-op.1480 */1481if(change_branch != o->branch1 || alt_path)1482 ret =update_file(o,0, changed_oid, changed_mode, update_path);1483}1484free(alt_path);14851486return ret;1487}14881489static inthandle_rename_delete(struct merge_options *o,1490struct diff_filepair *pair,1491const char*rename_branch,1492const char*delete_branch)1493{1494const struct diff_filespec *orig = pair->one;1495const struct diff_filespec *dest = pair->two;14961497if(handle_change_delete(o,1498 o->call_depth ? orig->path : dest->path,1499 o->call_depth ? NULL : orig->path,1500&orig->oid, orig->mode,1501&dest->oid, dest->mode,1502 rename_branch, delete_branch,1503_("rename"),_("renamed")))1504return-1;15051506if(o->call_depth)1507returnremove_file_from_cache(dest->path);1508else1509returnupdate_stages(o, dest->path, NULL,1510 rename_branch == o->branch1 ? dest : NULL,1511 rename_branch == o->branch1 ? NULL : dest);1512}15131514static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,1515struct stage_data *entry,1516int stage)1517{1518struct object_id *oid = &entry->stages[stage].oid;1519unsigned mode = entry->stages[stage].mode;1520if(mode ==0||is_null_oid(oid))1521return NULL;1522oidcpy(&target->oid, oid);1523 target->mode = mode;1524return target;1525}15261527static inthandle_file(struct merge_options *o,1528struct diff_filespec *rename,1529int stage,1530struct rename_conflict_info *ci)1531{1532char*dst_name = rename->path;1533struct stage_data *dst_entry;1534const char*cur_branch, *other_branch;1535struct diff_filespec other;1536struct diff_filespec *add;1537int ret;15381539if(stage ==2) {1540 dst_entry = ci->dst_entry1;1541 cur_branch = ci->branch1;1542 other_branch = ci->branch2;1543}else{1544 dst_entry = ci->dst_entry2;1545 cur_branch = ci->branch2;1546 other_branch = ci->branch1;1547}15481549 add =filespec_from_entry(&other, dst_entry, stage ^1);1550if(add) {1551int ren_src_was_dirty =was_dirty(o, rename->path);1552char*add_name =unique_path(o, rename->path, other_branch);1553if(update_file(o,0, &add->oid, add->mode, add_name))1554return-1;15551556if(ren_src_was_dirty) {1557output(o,1,_("Refusing to lose dirty file at%s"),1558 rename->path);1559}1560/*1561 * Because the double negatives somehow keep confusing me...1562 * 1) update_wd iff !ren_src_was_dirty.1563 * 2) no_wd iff !update_wd1564 * 3) so, no_wd == !!ren_src_was_dirty == ren_src_was_dirty1565 */1566remove_file(o,0, rename->path, ren_src_was_dirty);1567 dst_name =unique_path(o, rename->path, cur_branch);1568}else{1569if(dir_in_way(rename->path, !o->call_depth,0)) {1570 dst_name =unique_path(o, rename->path, cur_branch);1571output(o,1,_("%sis a directory in%sadding as%sinstead"),1572 rename->path, other_branch, dst_name);1573}else if(!o->call_depth &&1574would_lose_untracked(rename->path)) {1575 dst_name =unique_path(o, rename->path, cur_branch);1576output(o,1,_("Refusing to lose untracked file at%s; "1577"adding as%sinstead"),1578 rename->path, dst_name);1579}1580}1581if((ret =update_file(o,0, &rename->oid, rename->mode, dst_name)))1582;/* fall through, do allow dst_name to be released */1583else if(stage ==2)1584 ret =update_stages(o, rename->path, NULL, rename, add);1585else1586 ret =update_stages(o, rename->path, NULL, add, rename);15871588if(dst_name != rename->path)1589free(dst_name);15901591return ret;1592}15931594static inthandle_rename_rename_1to2(struct merge_options *o,1595struct rename_conflict_info *ci)1596{1597/* One file was renamed in both branches, but to different names. */1598struct diff_filespec *one = ci->pair1->one;1599struct diff_filespec *a = ci->pair1->two;1600struct diff_filespec *b = ci->pair2->two;16011602output(o,1,_("CONFLICT (rename/rename): "1603"Rename\"%s\"->\"%s\"in branch\"%s\""1604"rename\"%s\"->\"%s\"in\"%s\"%s"),1605 one->path, a->path, ci->branch1,1606 one->path, b->path, ci->branch2,1607 o->call_depth ?_(" (left unresolved)") :"");1608if(o->call_depth) {1609struct merge_file_info mfi;1610struct diff_filespec other;1611struct diff_filespec *add;1612if(merge_mode_and_contents(o, one, a, b, one->path,1613 ci->branch1, ci->branch2, &mfi))1614return-1;16151616/*1617 * FIXME: For rename/add-source conflicts (if we could detect1618 * such), this is wrong. We should instead find a unique1619 * pathname and then either rename the add-source file to that1620 * unique path, or use that unique path instead of src here.1621 */1622if(update_file(o,0, &mfi.oid, mfi.mode, one->path))1623return-1;16241625/*1626 * Above, we put the merged content at the merge-base's1627 * path. Now we usually need to delete both a->path and1628 * b->path. However, the rename on each side of the merge1629 * could also be involved in a rename/add conflict. In1630 * such cases, we should keep the added file around,1631 * resolving the conflict at that path in its favor.1632 */1633 add =filespec_from_entry(&other, ci->dst_entry1,2^1);1634if(add) {1635if(update_file(o,0, &add->oid, add->mode, a->path))1636return-1;1637}1638else1639remove_file_from_cache(a->path);1640 add =filespec_from_entry(&other, ci->dst_entry2,3^1);1641if(add) {1642if(update_file(o,0, &add->oid, add->mode, b->path))1643return-1;1644}1645else1646remove_file_from_cache(b->path);1647}else if(handle_file(o, a,2, ci) ||handle_file(o, b,3, ci))1648return-1;16491650return0;1651}16521653static inthandle_rename_rename_2to1(struct merge_options *o,1654struct rename_conflict_info *ci)1655{1656/* Two files, a & b, were renamed to the same thing, c. */1657struct diff_filespec *a = ci->pair1->one;1658struct diff_filespec *b = ci->pair2->one;1659struct diff_filespec *c1 = ci->pair1->two;1660struct diff_filespec *c2 = ci->pair2->two;1661char*path = c1->path;/* == c2->path */1662char*path_side_1_desc;1663char*path_side_2_desc;1664struct merge_file_info mfi_c1;1665struct merge_file_info mfi_c2;1666int ret;16671668output(o,1,_("CONFLICT (rename/rename): "1669"Rename%s->%sin%s. "1670"Rename%s->%sin%s"),1671 a->path, c1->path, ci->branch1,1672 b->path, c2->path, ci->branch2);16731674remove_file(o,1, a->path, o->call_depth ||would_lose_untracked(a->path));1675remove_file(o,1, b->path, o->call_depth ||would_lose_untracked(b->path));16761677 path_side_1_desc =xstrfmt("%s(was%s)", path, a->path);1678 path_side_2_desc =xstrfmt("%s(was%s)", path, b->path);1679if(merge_mode_and_contents(o, a, c1, &ci->ren1_other, path_side_1_desc,1680 o->branch1, o->branch2, &mfi_c1) ||1681merge_mode_and_contents(o, b, &ci->ren2_other, c2, path_side_2_desc,1682 o->branch1, o->branch2, &mfi_c2))1683return-1;1684free(path_side_1_desc);1685free(path_side_2_desc);16861687if(o->call_depth) {1688/*1689 * If mfi_c1.clean && mfi_c2.clean, then it might make1690 * sense to do a two-way merge of those results. But, I1691 * think in all cases, it makes sense to have the virtual1692 * merge base just undo the renames; they can be detected1693 * again later for the non-recursive merge.1694 */1695remove_file(o,0, path,0);1696 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, a->path);1697if(!ret)1698 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1699 b->path);1700}else{1701char*new_path1 =unique_path(o, path, ci->branch1);1702char*new_path2 =unique_path(o, path, ci->branch2);1703output(o,1,_("Renaming%sto%sand%sto%sinstead"),1704 a->path, new_path1, b->path, new_path2);1705if(was_dirty(o, path))1706output(o,1,_("Refusing to lose dirty file at%s"),1707 path);1708else if(would_lose_untracked(path))1709/*1710 * Only way we get here is if both renames were from1711 * a directory rename AND user had an untracked file1712 * at the location where both files end up after the1713 * two directory renames. See testcase 10d of t6043.1714 */1715output(o,1,_("Refusing to lose untracked file at "1716"%s, even though it's in the way."),1717 path);1718else1719remove_file(o,0, path,0);1720 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, new_path1);1721if(!ret)1722 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1723 new_path2);1724/*1725 * unpack_trees() actually populates the index for us for1726 * "normal" rename/rename(2to1) situtations so that the1727 * correct entries are at the higher stages, which would1728 * make the call below to update_stages_for_stage_data1729 * unnecessary. However, if either of the renames came1730 * from a directory rename, then unpack_trees() will not1731 * have gotten the right data loaded into the index, so we1732 * need to do so now. (While it'd be tempting to move this1733 * call to update_stages_for_stage_data() to1734 * apply_directory_rename_modifications(), that would break1735 * our intermediate calls to would_lose_untracked() since1736 * those rely on the current in-memory index. See also the1737 * big "NOTE" in update_stages()).1738 */1739if(update_stages_for_stage_data(o, path, ci->dst_entry1))1740 ret = -1;17411742free(new_path2);1743free(new_path1);1744}17451746return ret;1747}17481749/*1750 * Get the diff_filepairs changed between o_tree and tree.1751 */1752static struct diff_queue_struct *get_diffpairs(struct merge_options *o,1753struct tree *o_tree,1754struct tree *tree)1755{1756struct diff_queue_struct *ret;1757struct diff_options opts;17581759diff_setup(&opts);1760 opts.flags.recursive =1;1761 opts.flags.rename_empty =0;1762 opts.detect_rename =merge_detect_rename(o);1763/*1764 * We do not have logic to handle the detection of copies. In1765 * fact, it may not even make sense to add such logic: would we1766 * really want a change to a base file to be propagated through1767 * multiple other files by a merge?1768 */1769if(opts.detect_rename > DIFF_DETECT_RENAME)1770 opts.detect_rename = DIFF_DETECT_RENAME;1771 opts.rename_limit = o->merge_rename_limit >=0? o->merge_rename_limit :1772 o->diff_rename_limit >=0? o->diff_rename_limit :17731000;1774 opts.rename_score = o->rename_score;1775 opts.show_rename_progress = o->show_rename_progress;1776 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1777diff_setup_done(&opts);1778diff_tree_oid(&o_tree->object.oid, &tree->object.oid,"", &opts);1779diffcore_std(&opts);1780if(opts.needed_rename_limit > o->needed_rename_limit)1781 o->needed_rename_limit = opts.needed_rename_limit;17821783 ret =xmalloc(sizeof(*ret));1784*ret = diff_queued_diff;17851786 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1787 diff_queued_diff.nr =0;1788 diff_queued_diff.queue = NULL;1789diff_flush(&opts);1790return ret;1791}17921793static inttree_has_path(struct tree *tree,const char*path)1794{1795struct object_id hashy;1796unsigned int mode_o;17971798return!get_tree_entry(&tree->object.oid, path,1799&hashy, &mode_o);1800}18011802/*1803 * Return a new string that replaces the beginning portion (which matches1804 * entry->dir), with entry->new_dir. In perl-speak:1805 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1806 * NOTE:1807 * Caller must ensure that old_path starts with entry->dir + '/'.1808 */1809static char*apply_dir_rename(struct dir_rename_entry *entry,1810const char*old_path)1811{1812struct strbuf new_path = STRBUF_INIT;1813int oldlen, newlen;18141815if(entry->non_unique_new_dir)1816return NULL;18171818 oldlen =strlen(entry->dir);1819 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) +1;1820strbuf_grow(&new_path, newlen);1821strbuf_addbuf(&new_path, &entry->new_dir);1822strbuf_addstr(&new_path, &old_path[oldlen]);18231824returnstrbuf_detach(&new_path, NULL);1825}18261827static voidget_renamed_dir_portion(const char*old_path,const char*new_path,1828char**old_dir,char**new_dir)1829{1830char*end_of_old, *end_of_new;1831int old_len, new_len;18321833*old_dir = NULL;1834*new_dir = NULL;18351836/*1837 * For1838 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1839 * the "e/foo.c" part is the same, we just want to know that1840 * "a/b/c/d" was renamed to "a/b/some/thing/else"1841 * so, for this example, this function returns "a/b/c/d" in1842 * *old_dir and "a/b/some/thing/else" in *new_dir.1843 *1844 * Also, if the basename of the file changed, we don't care. We1845 * want to know which portion of the directory, if any, changed.1846 */1847 end_of_old =strrchr(old_path,'/');1848 end_of_new =strrchr(new_path,'/');18491850if(end_of_old == NULL || end_of_new == NULL)1851return;1852while(*--end_of_new == *--end_of_old &&1853 end_of_old != old_path &&1854 end_of_new != new_path)1855;/* Do nothing; all in the while loop */1856/*1857 * We've found the first non-matching character in the directory1858 * paths. That means the current directory we were comparing1859 * represents the rename. Move end_of_old and end_of_new back1860 * to the full directory name.1861 */1862if(*end_of_old =='/')1863 end_of_old++;1864if(*end_of_old !='/')1865 end_of_new++;1866 end_of_old =strchr(end_of_old,'/');1867 end_of_new =strchr(end_of_new,'/');18681869/*1870 * It may have been the case that old_path and new_path were the same1871 * directory all along. Don't claim a rename if they're the same.1872 */1873 old_len = end_of_old - old_path;1874 new_len = end_of_new - new_path;18751876if(old_len != new_len ||strncmp(old_path, new_path, old_len)) {1877*old_dir =xstrndup(old_path, old_len);1878*new_dir =xstrndup(new_path, new_len);1879}1880}18811882static voidremove_hashmap_entries(struct hashmap *dir_renames,1883struct string_list *items_to_remove)1884{1885int i;1886struct dir_rename_entry *entry;18871888for(i =0; i < items_to_remove->nr; i++) {1889 entry = items_to_remove->items[i].util;1890hashmap_remove(dir_renames, entry, NULL);1891}1892string_list_clear(items_to_remove,0);1893}18941895/*1896 * See if there is a directory rename for path, and if there are any file1897 * level conflicts for the renamed location. If there is a rename and1898 * there are no conflicts, return the new name. Otherwise, return NULL.1899 */1900static char*handle_path_level_conflicts(struct merge_options *o,1901const char*path,1902struct dir_rename_entry *entry,1903struct hashmap *collisions,1904struct tree *tree)1905{1906char*new_path = NULL;1907struct collision_entry *collision_ent;1908int clean =1;1909struct strbuf collision_paths = STRBUF_INIT;19101911/*1912 * entry has the mapping of old directory name to new directory name1913 * that we want to apply to path.1914 */1915 new_path =apply_dir_rename(entry, path);19161917if(!new_path) {1918/* This should only happen when entry->non_unique_new_dir set */1919if(!entry->non_unique_new_dir)1920BUG("entry->non_unqiue_dir not set and !new_path");1921output(o,1,_("CONFLICT (directory rename split): "1922"Unclear where to place%sbecause directory "1923"%swas renamed to multiple other directories, "1924"with no destination getting a majority of the "1925"files."),1926 path, entry->dir);1927 clean =0;1928return NULL;1929}19301931/*1932 * The caller needs to have ensured that it has pre-populated1933 * collisions with all paths that map to new_path. Do a quick check1934 * to ensure that's the case.1935 */1936 collision_ent =collision_find_entry(collisions, new_path);1937if(collision_ent == NULL)1938BUG("collision_ent is NULL");19391940/*1941 * Check for one-sided add/add/.../add conflicts, i.e.1942 * where implicit renames from the other side doing1943 * directory rename(s) can affect this side of history1944 * to put multiple paths into the same location. Warn1945 * and bail on directory renames for such paths.1946 */1947if(collision_ent->reported_already) {1948 clean =0;1949}else if(tree_has_path(tree, new_path)) {1950 collision_ent->reported_already =1;1951strbuf_add_separated_string_list(&collision_paths,", ",1952&collision_ent->source_files);1953output(o,1,_("CONFLICT (implicit dir rename): Existing "1954"file/dir at%sin the way of implicit "1955"directory rename(s) putting the following "1956"path(s) there:%s."),1957 new_path, collision_paths.buf);1958 clean =0;1959}else if(collision_ent->source_files.nr >1) {1960 collision_ent->reported_already =1;1961strbuf_add_separated_string_list(&collision_paths,", ",1962&collision_ent->source_files);1963output(o,1,_("CONFLICT (implicit dir rename): Cannot map "1964"more than one path to%s; implicit directory "1965"renames tried to put these paths there:%s"),1966 new_path, collision_paths.buf);1967 clean =0;1968}19691970/* Free memory we no longer need */1971strbuf_release(&collision_paths);1972if(!clean && new_path) {1973free(new_path);1974return NULL;1975}19761977return new_path;1978}19791980/*1981 * There are a couple things we want to do at the directory level:1982 * 1. Check for both sides renaming to the same thing, in order to avoid1983 * implicit renaming of files that should be left in place. (See1984 * testcase 6b in t6043 for details.)1985 * 2. Prune directory renames if there are still files left in the1986 * the original directory. These represent a partial directory rename,1987 * i.e. a rename where only some of the files within the directory1988 * were renamed elsewhere. (Technically, this could be done earlier1989 * in get_directory_renames(), except that would prevent us from1990 * doing the previous check and thus failing testcase 6b.)1991 * 3. Check for rename/rename(1to2) conflicts (at the directory level).1992 * In the future, we could potentially record this info as well and1993 * omit reporting rename/rename(1to2) conflicts for each path within1994 * the affected directories, thus cleaning up the merge output.1995 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the1996 * directory level, because merging directories is fine. If it1997 * causes conflicts for files within those merged directories, then1998 * that should be detected at the individual path level.1999 */2000static voidhandle_directory_level_conflicts(struct merge_options *o,2001struct hashmap *dir_re_head,2002struct tree *head,2003struct hashmap *dir_re_merge,2004struct tree *merge)2005{2006struct hashmap_iter iter;2007struct dir_rename_entry *head_ent;2008struct dir_rename_entry *merge_ent;20092010struct string_list remove_from_head = STRING_LIST_INIT_NODUP;2011struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;20122013hashmap_iter_init(dir_re_head, &iter);2014while((head_ent =hashmap_iter_next(&iter))) {2015 merge_ent =dir_rename_find_entry(dir_re_merge, head_ent->dir);2016if(merge_ent &&2017!head_ent->non_unique_new_dir &&2018!merge_ent->non_unique_new_dir &&2019!strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {2020/* 1. Renamed identically; remove it from both sides */2021string_list_append(&remove_from_head,2022 head_ent->dir)->util = head_ent;2023strbuf_release(&head_ent->new_dir);2024string_list_append(&remove_from_merge,2025 merge_ent->dir)->util = merge_ent;2026strbuf_release(&merge_ent->new_dir);2027}else if(tree_has_path(head, head_ent->dir)) {2028/* 2. This wasn't a directory rename after all */2029string_list_append(&remove_from_head,2030 head_ent->dir)->util = head_ent;2031strbuf_release(&head_ent->new_dir);2032}2033}20342035remove_hashmap_entries(dir_re_head, &remove_from_head);2036remove_hashmap_entries(dir_re_merge, &remove_from_merge);20372038hashmap_iter_init(dir_re_merge, &iter);2039while((merge_ent =hashmap_iter_next(&iter))) {2040 head_ent =dir_rename_find_entry(dir_re_head, merge_ent->dir);2041if(tree_has_path(merge, merge_ent->dir)) {2042/* 2. This wasn't a directory rename after all */2043string_list_append(&remove_from_merge,2044 merge_ent->dir)->util = merge_ent;2045}else if(head_ent &&2046!head_ent->non_unique_new_dir &&2047!merge_ent->non_unique_new_dir) {2048/* 3. rename/rename(1to2) */2049/*2050 * We can assume it's not rename/rename(1to1) because2051 * that was case (1), already checked above. So we2052 * know that head_ent->new_dir and merge_ent->new_dir2053 * are different strings.2054 */2055output(o,1,_("CONFLICT (rename/rename): "2056"Rename directory%s->%sin%s. "2057"Rename directory%s->%sin%s"),2058 head_ent->dir, head_ent->new_dir.buf, o->branch1,2059 head_ent->dir, merge_ent->new_dir.buf, o->branch2);2060string_list_append(&remove_from_head,2061 head_ent->dir)->util = head_ent;2062strbuf_release(&head_ent->new_dir);2063string_list_append(&remove_from_merge,2064 merge_ent->dir)->util = merge_ent;2065strbuf_release(&merge_ent->new_dir);2066}2067}20682069remove_hashmap_entries(dir_re_head, &remove_from_head);2070remove_hashmap_entries(dir_re_merge, &remove_from_merge);2071}20722073static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,2074struct tree *tree)2075{2076struct hashmap *dir_renames;2077struct hashmap_iter iter;2078struct dir_rename_entry *entry;2079int i;20802081/*2082 * Typically, we think of a directory rename as all files from a2083 * certain directory being moved to a target directory. However,2084 * what if someone first moved two files from the original2085 * directory in one commit, and then renamed the directory2086 * somewhere else in a later commit? At merge time, we just know2087 * that files from the original directory went to two different2088 * places, and that the bulk of them ended up in the same place.2089 * We want each directory rename to represent where the bulk of the2090 * files from that directory end up; this function exists to find2091 * where the bulk of the files went.2092 *2093 * The first loop below simply iterates through the list of file2094 * renames, finding out how often each directory rename pair2095 * possibility occurs.2096 */2097 dir_renames =xmalloc(sizeof(*dir_renames));2098dir_rename_init(dir_renames);2099for(i =0; i < pairs->nr; ++i) {2100struct string_list_item *item;2101int*count;2102struct diff_filepair *pair = pairs->queue[i];2103char*old_dir, *new_dir;21042105/* File not part of directory rename if it wasn't renamed */2106if(pair->status !='R')2107continue;21082109get_renamed_dir_portion(pair->one->path, pair->two->path,2110&old_dir, &new_dir);2111if(!old_dir)2112/* Directory didn't change at all; ignore this one. */2113continue;21142115 entry =dir_rename_find_entry(dir_renames, old_dir);2116if(!entry) {2117 entry =xmalloc(sizeof(*entry));2118dir_rename_entry_init(entry, old_dir);2119hashmap_put(dir_renames, entry);2120}else{2121free(old_dir);2122}2123 item =string_list_lookup(&entry->possible_new_dirs, new_dir);2124if(!item) {2125 item =string_list_insert(&entry->possible_new_dirs,2126 new_dir);2127 item->util =xcalloc(1,sizeof(int));2128}else{2129free(new_dir);2130}2131 count = item->util;2132*count +=1;2133}21342135/*2136 * For each directory with files moved out of it, we find out which2137 * target directory received the most files so we can declare it to2138 * be the "winning" target location for the directory rename. This2139 * winner gets recorded in new_dir. If there is no winner2140 * (multiple target directories received the same number of files),2141 * we set non_unique_new_dir. Once we've determined the winner (or2142 * that there is no winner), we no longer need possible_new_dirs.2143 */2144hashmap_iter_init(dir_renames, &iter);2145while((entry =hashmap_iter_next(&iter))) {2146int max =0;2147int bad_max =0;2148char*best = NULL;21492150for(i =0; i < entry->possible_new_dirs.nr; i++) {2151int*count = entry->possible_new_dirs.items[i].util;21522153if(*count == max)2154 bad_max = max;2155else if(*count > max) {2156 max = *count;2157 best = entry->possible_new_dirs.items[i].string;2158}2159}2160if(bad_max == max)2161 entry->non_unique_new_dir =1;2162else{2163assert(entry->new_dir.len ==0);2164strbuf_addstr(&entry->new_dir, best);2165}2166/*2167 * The relevant directory sub-portion of the original full2168 * filepaths were xstrndup'ed before inserting into2169 * possible_new_dirs, and instead of manually iterating the2170 * list and free'ing each, just lie and tell2171 * possible_new_dirs that it did the strdup'ing so that it2172 * will free them for us.2173 */2174 entry->possible_new_dirs.strdup_strings =1;2175string_list_clear(&entry->possible_new_dirs,1);2176}21772178return dir_renames;2179}21802181static struct dir_rename_entry *check_dir_renamed(const char*path,2182struct hashmap *dir_renames)2183{2184char*temp =xstrdup(path);2185char*end;2186struct dir_rename_entry *entry = NULL;21872188while((end =strrchr(temp,'/'))) {2189*end ='\0';2190 entry =dir_rename_find_entry(dir_renames, temp);2191if(entry)2192break;2193}2194free(temp);2195return entry;2196}21972198static voidcompute_collisions(struct hashmap *collisions,2199struct hashmap *dir_renames,2200struct diff_queue_struct *pairs)2201{2202int i;22032204/*2205 * Multiple files can be mapped to the same path due to directory2206 * renames done by the other side of history. Since that other2207 * side of history could have merged multiple directories into one,2208 * if our side of history added the same file basename to each of2209 * those directories, then all N of them would get implicitly2210 * renamed by the directory rename detection into the same path,2211 * and we'd get an add/add/.../add conflict, and all those adds2212 * from *this* side of history. This is not representable in the2213 * index, and users aren't going to easily be able to make sense of2214 * it. So we need to provide a good warning about what's2215 * happening, and fall back to no-directory-rename detection2216 * behavior for those paths.2217 *2218 * See testcases 9e and all of section 5 from t6043 for examples.2219 */2220collision_init(collisions);22212222for(i =0; i < pairs->nr; ++i) {2223struct dir_rename_entry *dir_rename_ent;2224struct collision_entry *collision_ent;2225char*new_path;2226struct diff_filepair *pair = pairs->queue[i];22272228if(pair->status !='A'&& pair->status !='R')2229continue;2230 dir_rename_ent =check_dir_renamed(pair->two->path,2231 dir_renames);2232if(!dir_rename_ent)2233continue;22342235 new_path =apply_dir_rename(dir_rename_ent, pair->two->path);2236if(!new_path)2237/*2238 * dir_rename_ent->non_unique_new_path is true, which2239 * means there is no directory rename for us to use,2240 * which means it won't cause us any additional2241 * collisions.2242 */2243continue;2244 collision_ent =collision_find_entry(collisions, new_path);2245if(!collision_ent) {2246 collision_ent =xcalloc(1,2247sizeof(struct collision_entry));2248hashmap_entry_init(collision_ent,strhash(new_path));2249hashmap_put(collisions, collision_ent);2250 collision_ent->target_file = new_path;2251}else{2252free(new_path);2253}2254string_list_insert(&collision_ent->source_files,2255 pair->two->path);2256}2257}22582259static char*check_for_directory_rename(struct merge_options *o,2260const char*path,2261struct tree *tree,2262struct hashmap *dir_renames,2263struct hashmap *dir_rename_exclusions,2264struct hashmap *collisions,2265int*clean_merge)2266{2267char*new_path = NULL;2268struct dir_rename_entry *entry =check_dir_renamed(path, dir_renames);2269struct dir_rename_entry *oentry = NULL;22702271if(!entry)2272return new_path;22732274/*2275 * This next part is a little weird. We do not want to do an2276 * implicit rename into a directory we renamed on our side, because2277 * that will result in a spurious rename/rename(1to2) conflict. An2278 * example:2279 * Base commit: dumbdir/afile, otherdir/bfile2280 * Side 1: smrtdir/afile, otherdir/bfile2281 * Side 2: dumbdir/afile, dumbdir/bfile2282 * Here, while working on Side 1, we could notice that otherdir was2283 * renamed/merged to dumbdir, and change the diff_filepair for2284 * otherdir/bfile into a rename into dumbdir/bfile. However, Side2285 * 2 will notice the rename from dumbdir to smrtdir, and do the2286 * transitive rename to move it from dumbdir/bfile to2287 * smrtdir/bfile. That gives us bfile in dumbdir vs being in2288 * smrtdir, a rename/rename(1to2) conflict. We really just want2289 * the file to end up in smrtdir. And the way to achieve that is2290 * to not let Side1 do the rename to dumbdir, since we know that is2291 * the source of one of our directory renames.2292 *2293 * That's why oentry and dir_rename_exclusions is here.2294 *2295 * As it turns out, this also prevents N-way transient rename2296 * confusion; See testcases 9c and 9d of t6043.2297 */2298 oentry =dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);2299if(oentry) {2300output(o,1,_("WARNING: Avoiding applying%s->%srename "2301"to%s, because%sitself was renamed."),2302 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);2303}else{2304 new_path =handle_path_level_conflicts(o, path, entry,2305 collisions, tree);2306*clean_merge &= (new_path != NULL);2307}23082309return new_path;2310}23112312static voidapply_directory_rename_modifications(struct merge_options *o,2313struct diff_filepair *pair,2314char*new_path,2315struct rename *re,2316struct tree *tree,2317struct tree *o_tree,2318struct tree *a_tree,2319struct tree *b_tree,2320struct string_list *entries,2321int*clean)2322{2323struct string_list_item *item;2324int stage = (tree == a_tree ?2:3);2325int update_wd;23262327/*2328 * In all cases where we can do directory rename detection,2329 * unpack_trees() will have read pair->two->path into the2330 * index and the working copy. We need to remove it so that2331 * we can instead place it at new_path. It is guaranteed to2332 * not be untracked (unpack_trees() would have errored out2333 * saying the file would have been overwritten), but it might2334 * be dirty, though.2335 */2336 update_wd = !was_dirty(o, pair->two->path);2337if(!update_wd)2338output(o,1,_("Refusing to lose dirty file at%s"),2339 pair->two->path);2340remove_file(o,1, pair->two->path, !update_wd);23412342/* Find or create a new re->dst_entry */2343 item =string_list_lookup(entries, new_path);2344if(item) {2345/*2346 * Since we're renaming on this side of history, and it's2347 * due to a directory rename on the other side of history2348 * (which we only allow when the directory in question no2349 * longer exists on the other side of history), the2350 * original entry for re->dst_entry is no longer2351 * necessary...2352 */2353 re->dst_entry->processed =1;23542355/*2356 * ...because we'll be using this new one.2357 */2358 re->dst_entry = item->util;2359}else{2360/*2361 * re->dst_entry is for the before-dir-rename path, and we2362 * need it to hold information for the after-dir-rename2363 * path. Before creating a new entry, we need to mark the2364 * old one as unnecessary (...unless it is shared by2365 * src_entry, i.e. this didn't use to be a rename, in which2366 * case we can just allow the normal processing to happen2367 * for it).2368 */2369if(pair->status =='R')2370 re->dst_entry->processed =1;23712372 re->dst_entry =insert_stage_data(new_path,2373 o_tree, a_tree, b_tree,2374 entries);2375 item =string_list_insert(entries, new_path);2376 item->util = re->dst_entry;2377}23782379/*2380 * Update the stage_data with the information about the path we are2381 * moving into place. That slot will be empty and available for us2382 * to write to because of the collision checks in2383 * handle_path_level_conflicts(). In other words,2384 * re->dst_entry->stages[stage].oid will be the null_oid, so it's2385 * open for us to write to.2386 *2387 * It may be tempting to actually update the index at this point as2388 * well, using update_stages_for_stage_data(), but as per the big2389 * "NOTE" in update_stages(), doing so will modify the current2390 * in-memory index which will break calls to would_lose_untracked()2391 * that we need to make. Instead, we need to just make sure that2392 * the various handle_rename_*() functions update the index2393 * explicitly rather than relying on unpack_trees() to have done it.2394 */2395get_tree_entry(&tree->object.oid,2396 pair->two->path,2397&re->dst_entry->stages[stage].oid,2398&re->dst_entry->stages[stage].mode);23992400/* Update pair status */2401if(pair->status =='A') {2402/*2403 * Recording rename information for this add makes it look2404 * like a rename/delete conflict. Make sure we can2405 * correctly handle this as an add that was moved to a new2406 * directory instead of reporting a rename/delete conflict.2407 */2408 re->add_turned_into_rename =1;2409}2410/*2411 * We don't actually look at pair->status again, but it seems2412 * pedagogically correct to adjust it.2413 */2414 pair->status ='R';24152416/*2417 * Finally, record the new location.2418 */2419 pair->two->path = new_path;2420}24212422/*2423 * Get information of all renames which occurred in 'pairs', making use of2424 * any implicit directory renames inferred from the other side of history.2425 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')2426 * to be able to associate the correct cache entries with the rename2427 * information; tree is always equal to either a_tree or b_tree.2428 */2429static struct string_list *get_renames(struct merge_options *o,2430struct diff_queue_struct *pairs,2431struct hashmap *dir_renames,2432struct hashmap *dir_rename_exclusions,2433struct tree *tree,2434struct tree *o_tree,2435struct tree *a_tree,2436struct tree *b_tree,2437struct string_list *entries,2438int*clean_merge)2439{2440int i;2441struct hashmap collisions;2442struct hashmap_iter iter;2443struct collision_entry *e;2444struct string_list *renames;24452446compute_collisions(&collisions, dir_renames, pairs);2447 renames =xcalloc(1,sizeof(struct string_list));24482449for(i =0; i < pairs->nr; ++i) {2450struct string_list_item *item;2451struct rename *re;2452struct diff_filepair *pair = pairs->queue[i];2453char*new_path;/* non-NULL only with directory renames */24542455if(pair->status !='A'&& pair->status !='R') {2456diff_free_filepair(pair);2457continue;2458}2459 new_path =check_for_directory_rename(o, pair->two->path, tree,2460 dir_renames,2461 dir_rename_exclusions,2462&collisions,2463 clean_merge);2464if(pair->status !='R'&& !new_path) {2465diff_free_filepair(pair);2466continue;2467}24682469 re =xmalloc(sizeof(*re));2470 re->processed =0;2471 re->add_turned_into_rename =0;2472 re->pair = pair;2473 item =string_list_lookup(entries, re->pair->one->path);2474if(!item)2475 re->src_entry =insert_stage_data(re->pair->one->path,2476 o_tree, a_tree, b_tree, entries);2477else2478 re->src_entry = item->util;24792480 item =string_list_lookup(entries, re->pair->two->path);2481if(!item)2482 re->dst_entry =insert_stage_data(re->pair->two->path,2483 o_tree, a_tree, b_tree, entries);2484else2485 re->dst_entry = item->util;2486 item =string_list_insert(renames, pair->one->path);2487 item->util = re;2488if(new_path)2489apply_directory_rename_modifications(o, pair, new_path,2490 re, tree, o_tree,2491 a_tree, b_tree,2492 entries,2493 clean_merge);2494}24952496hashmap_iter_init(&collisions, &iter);2497while((e =hashmap_iter_next(&iter))) {2498free(e->target_file);2499string_list_clear(&e->source_files,0);2500}2501hashmap_free(&collisions,1);2502return renames;2503}25042505static intprocess_renames(struct merge_options *o,2506struct string_list *a_renames,2507struct string_list *b_renames)2508{2509int clean_merge =1, i, j;2510struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2511struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2512const struct rename *sre;25132514for(i =0; i < a_renames->nr; i++) {2515 sre = a_renames->items[i].util;2516string_list_insert(&a_by_dst, sre->pair->two->path)->util2517= (void*)sre;2518}2519for(i =0; i < b_renames->nr; i++) {2520 sre = b_renames->items[i].util;2521string_list_insert(&b_by_dst, sre->pair->two->path)->util2522= (void*)sre;2523}25242525for(i =0, j =0; i < a_renames->nr || j < b_renames->nr;) {2526struct string_list *renames1, *renames2Dst;2527struct rename *ren1 = NULL, *ren2 = NULL;2528const char*branch1, *branch2;2529const char*ren1_src, *ren1_dst;2530struct string_list_item *lookup;25312532if(i >= a_renames->nr) {2533 ren2 = b_renames->items[j++].util;2534}else if(j >= b_renames->nr) {2535 ren1 = a_renames->items[i++].util;2536}else{2537int compare =strcmp(a_renames->items[i].string,2538 b_renames->items[j].string);2539if(compare <=0)2540 ren1 = a_renames->items[i++].util;2541if(compare >=0)2542 ren2 = b_renames->items[j++].util;2543}25442545/* TODO: refactor, so that 1/2 are not needed */2546if(ren1) {2547 renames1 = a_renames;2548 renames2Dst = &b_by_dst;2549 branch1 = o->branch1;2550 branch2 = o->branch2;2551}else{2552 renames1 = b_renames;2553 renames2Dst = &a_by_dst;2554 branch1 = o->branch2;2555 branch2 = o->branch1;2556SWAP(ren2, ren1);2557}25582559if(ren1->processed)2560continue;2561 ren1->processed =1;2562 ren1->dst_entry->processed =1;2563/* BUG: We should only mark src_entry as processed if we2564 * are not dealing with a rename + add-source case.2565 */2566 ren1->src_entry->processed =1;25672568 ren1_src = ren1->pair->one->path;2569 ren1_dst = ren1->pair->two->path;25702571if(ren2) {2572/* One file renamed on both sides */2573const char*ren2_src = ren2->pair->one->path;2574const char*ren2_dst = ren2->pair->two->path;2575enum rename_type rename_type;2576if(strcmp(ren1_src, ren2_src) !=0)2577BUG("ren1_src != ren2_src");2578 ren2->dst_entry->processed =1;2579 ren2->processed =1;2580if(strcmp(ren1_dst, ren2_dst) !=0) {2581 rename_type = RENAME_ONE_FILE_TO_TWO;2582 clean_merge =0;2583}else{2584 rename_type = RENAME_ONE_FILE_TO_ONE;2585/* BUG: We should only remove ren1_src in2586 * the base stage (think of rename +2587 * add-source cases).2588 */2589remove_file(o,1, ren1_src,1);2590update_entry(ren1->dst_entry,2591 ren1->pair->one,2592 ren1->pair->two,2593 ren2->pair->two);2594}2595setup_rename_conflict_info(rename_type,2596 ren1->pair,2597 ren2->pair,2598 branch1,2599 branch2,2600 ren1->dst_entry,2601 ren2->dst_entry,2602 o,2603 NULL,2604 NULL);2605}else if((lookup =string_list_lookup(renames2Dst, ren1_dst))) {2606/* Two different files renamed to the same thing */2607char*ren2_dst;2608 ren2 = lookup->util;2609 ren2_dst = ren2->pair->two->path;2610if(strcmp(ren1_dst, ren2_dst) !=0)2611BUG("ren1_dst != ren2_dst");26122613 clean_merge =0;2614 ren2->processed =1;2615/*2616 * BUG: We should only mark src_entry as processed2617 * if we are not dealing with a rename + add-source2618 * case.2619 */2620 ren2->src_entry->processed =1;26212622setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2623 ren1->pair,2624 ren2->pair,2625 branch1,2626 branch2,2627 ren1->dst_entry,2628 ren2->dst_entry,2629 o,2630 ren1->src_entry,2631 ren2->src_entry);26322633}else{2634/* Renamed in 1, maybe changed in 2 */2635/* we only use sha1 and mode of these */2636struct diff_filespec src_other, dst_other;2637int try_merge;26382639/*2640 * unpack_trees loads entries from common-commit2641 * into stage 1, from head-commit into stage 2, and2642 * from merge-commit into stage 3. We keep track2643 * of which side corresponds to the rename.2644 */2645int renamed_stage = a_renames == renames1 ?2:3;2646int other_stage = a_renames == renames1 ?3:2;26472648/* BUG: We should only remove ren1_src in the base2649 * stage and in other_stage (think of rename +2650 * add-source case).2651 */2652remove_file(o,1, ren1_src,2653 renamed_stage ==2|| !was_tracked(o, ren1_src));26542655oidcpy(&src_other.oid,2656&ren1->src_entry->stages[other_stage].oid);2657 src_other.mode = ren1->src_entry->stages[other_stage].mode;2658oidcpy(&dst_other.oid,2659&ren1->dst_entry->stages[other_stage].oid);2660 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2661 try_merge =0;26622663if(oid_eq(&src_other.oid, &null_oid) &&2664 ren1->add_turned_into_rename) {2665setup_rename_conflict_info(RENAME_VIA_DIR,2666 ren1->pair,2667 NULL,2668 branch1,2669 branch2,2670 ren1->dst_entry,2671 NULL,2672 o,2673 NULL,2674 NULL);2675}else if(oid_eq(&src_other.oid, &null_oid)) {2676setup_rename_conflict_info(RENAME_DELETE,2677 ren1->pair,2678 NULL,2679 branch1,2680 branch2,2681 ren1->dst_entry,2682 NULL,2683 o,2684 NULL,2685 NULL);2686}else if((dst_other.mode == ren1->pair->two->mode) &&2687oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2688/*2689 * Added file on the other side identical to2690 * the file being renamed: clean merge.2691 * Also, there is no need to overwrite the2692 * file already in the working copy, so call2693 * update_file_flags() instead of2694 * update_file().2695 */2696if(update_file_flags(o,2697&ren1->pair->two->oid,2698 ren1->pair->two->mode,2699 ren1_dst,27001,/* update_cache */27010/* update_wd */))2702 clean_merge = -1;2703}else if(!oid_eq(&dst_other.oid, &null_oid)) {2704 clean_merge =0;2705 try_merge =1;2706output(o,1,_("CONFLICT (rename/add): Rename%s->%sin%s. "2707"%sadded in%s"),2708 ren1_src, ren1_dst, branch1,2709 ren1_dst, branch2);2710if(o->call_depth) {2711struct merge_file_info mfi;2712struct diff_filespec one, a, b;27132714oidcpy(&one.oid, &null_oid);2715 one.mode =0;2716 one.path = ren1->pair->two->path;27172718oidcpy(&a.oid, &ren1->pair->two->oid);2719 a.mode = ren1->pair->two->mode;2720 a.path = one.path;27212722oidcpy(&b.oid, &dst_other.oid);2723 b.mode = dst_other.mode;2724 b.path = one.path;27252726if(merge_mode_and_contents(o, &one, &a, &b, ren1_dst,2727 branch1, branch2,2728&mfi)) {2729 clean_merge = -1;2730goto cleanup_and_return;2731}2732output(o,1,_("Adding merged%s"), ren1_dst);2733if(update_file(o,0, &mfi.oid,2734 mfi.mode, ren1_dst))2735 clean_merge = -1;2736 try_merge =0;2737}else{2738char*new_path =unique_path(o, ren1_dst, branch2);2739output(o,1,_("Adding as%sinstead"), new_path);2740if(update_file(o,0, &dst_other.oid,2741 dst_other.mode, new_path))2742 clean_merge = -1;2743free(new_path);2744}2745}else2746 try_merge =1;27472748if(clean_merge <0)2749goto cleanup_and_return;2750if(try_merge) {2751struct diff_filespec *one, *a, *b;2752 src_other.path = (char*)ren1_src;27532754 one = ren1->pair->one;2755if(a_renames == renames1) {2756 a = ren1->pair->two;2757 b = &src_other;2758}else{2759 b = ren1->pair->two;2760 a = &src_other;2761}2762update_entry(ren1->dst_entry, one, a, b);2763setup_rename_conflict_info(RENAME_NORMAL,2764 ren1->pair,2765 NULL,2766 branch1,2767 NULL,2768 ren1->dst_entry,2769 NULL,2770 o,2771 NULL,2772 NULL);2773}2774}2775}2776cleanup_and_return:2777string_list_clear(&a_by_dst,0);2778string_list_clear(&b_by_dst,0);27792780return clean_merge;2781}27822783struct rename_info {2784struct string_list *head_renames;2785struct string_list *merge_renames;2786};27872788static voidinitial_cleanup_rename(struct diff_queue_struct *pairs,2789struct hashmap *dir_renames)2790{2791struct hashmap_iter iter;2792struct dir_rename_entry *e;27932794hashmap_iter_init(dir_renames, &iter);2795while((e =hashmap_iter_next(&iter))) {2796free(e->dir);2797strbuf_release(&e->new_dir);2798/* possible_new_dirs already cleared in get_directory_renames */2799}2800hashmap_free(dir_renames,1);2801free(dir_renames);28022803free(pairs->queue);2804free(pairs);2805}28062807static intdetect_and_process_renames(struct merge_options *o,2808struct tree *common,2809struct tree *head,2810struct tree *merge,2811struct string_list *entries,2812struct rename_info *ri)2813{2814struct diff_queue_struct *head_pairs, *merge_pairs;2815struct hashmap *dir_re_head, *dir_re_merge;2816int clean =1;28172818 ri->head_renames = NULL;2819 ri->merge_renames = NULL;28202821if(!merge_detect_rename(o))2822return1;28232824 head_pairs =get_diffpairs(o, common, head);2825 merge_pairs =get_diffpairs(o, common, merge);28262827if(o->detect_directory_renames) {2828 dir_re_head =get_directory_renames(head_pairs, head);2829 dir_re_merge =get_directory_renames(merge_pairs, merge);28302831handle_directory_level_conflicts(o,2832 dir_re_head, head,2833 dir_re_merge, merge);2834}else{2835 dir_re_head =xmalloc(sizeof(*dir_re_head));2836 dir_re_merge =xmalloc(sizeof(*dir_re_merge));2837dir_rename_init(dir_re_head);2838dir_rename_init(dir_re_merge);2839}28402841 ri->head_renames =get_renames(o, head_pairs,2842 dir_re_merge, dir_re_head, head,2843 common, head, merge, entries,2844&clean);2845if(clean <0)2846goto cleanup;2847 ri->merge_renames =get_renames(o, merge_pairs,2848 dir_re_head, dir_re_merge, merge,2849 common, head, merge, entries,2850&clean);2851if(clean <0)2852goto cleanup;2853 clean &=process_renames(o, ri->head_renames, ri->merge_renames);28542855cleanup:2856/*2857 * Some cleanup is deferred until cleanup_renames() because the2858 * data structures are still needed and referenced in2859 * process_entry(). But there are a few things we can free now.2860 */2861initial_cleanup_rename(head_pairs, dir_re_head);2862initial_cleanup_rename(merge_pairs, dir_re_merge);28632864return clean;2865}28662867static voidfinal_cleanup_rename(struct string_list *rename)2868{2869const struct rename *re;2870int i;28712872if(rename == NULL)2873return;28742875for(i =0; i < rename->nr; i++) {2876 re = rename->items[i].util;2877diff_free_filepair(re->pair);2878}2879string_list_clear(rename,1);2880free(rename);2881}28822883static voidfinal_cleanup_renames(struct rename_info *re_info)2884{2885final_cleanup_rename(re_info->head_renames);2886final_cleanup_rename(re_info->merge_renames);2887}28882889static struct object_id *stage_oid(const struct object_id *oid,unsigned mode)2890{2891return(is_null_oid(oid) || mode ==0) ? NULL: (struct object_id *)oid;2892}28932894static intread_oid_strbuf(struct merge_options *o,2895const struct object_id *oid,2896struct strbuf *dst)2897{2898void*buf;2899enum object_type type;2900unsigned long size;2901 buf =read_object_file(oid, &type, &size);2902if(!buf)2903returnerr(o,_("cannot read object%s"),oid_to_hex(oid));2904if(type != OBJ_BLOB) {2905free(buf);2906returnerr(o,_("object%sis not a blob"),oid_to_hex(oid));2907}2908strbuf_attach(dst, buf, size, size +1);2909return0;2910}29112912static intblob_unchanged(struct merge_options *opt,2913const struct object_id *o_oid,2914unsigned o_mode,2915const struct object_id *a_oid,2916unsigned a_mode,2917int renormalize,const char*path)2918{2919struct strbuf o = STRBUF_INIT;2920struct strbuf a = STRBUF_INIT;2921int ret =0;/* assume changed for safety */29222923if(a_mode != o_mode)2924return0;2925if(oid_eq(o_oid, a_oid))2926return1;2927if(!renormalize)2928return0;29292930assert(o_oid && a_oid);2931if(read_oid_strbuf(opt, o_oid, &o) ||read_oid_strbuf(opt, a_oid, &a))2932goto error_return;2933/*2934 * Note: binary | is used so that both renormalizations are2935 * performed. Comparison can be skipped if both files are2936 * unchanged since their sha1s have already been compared.2937 */2938if(renormalize_buffer(&the_index, path, o.buf, o.len, &o) |2939renormalize_buffer(&the_index, path, a.buf, a.len, &a))2940 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));29412942error_return:2943strbuf_release(&o);2944strbuf_release(&a);2945return ret;2946}29472948static inthandle_modify_delete(struct merge_options *o,2949const char*path,2950struct object_id *o_oid,int o_mode,2951struct object_id *a_oid,int a_mode,2952struct object_id *b_oid,int b_mode)2953{2954const char*modify_branch, *delete_branch;2955struct object_id *changed_oid;2956int changed_mode;29572958if(a_oid) {2959 modify_branch = o->branch1;2960 delete_branch = o->branch2;2961 changed_oid = a_oid;2962 changed_mode = a_mode;2963}else{2964 modify_branch = o->branch2;2965 delete_branch = o->branch1;2966 changed_oid = b_oid;2967 changed_mode = b_mode;2968}29692970returnhandle_change_delete(o,2971 path, NULL,2972 o_oid, o_mode,2973 changed_oid, changed_mode,2974 modify_branch, delete_branch,2975_("modify"),_("modified"));2976}29772978static inthandle_content_merge(struct merge_options *o,2979const char*path,2980int is_dirty,2981struct object_id *o_oid,int o_mode,2982struct object_id *a_oid,int a_mode,2983struct object_id *b_oid,int b_mode,2984struct rename_conflict_info *rename_conflict_info)2985{2986const char*reason =_("content");2987const char*path1 = NULL, *path2 = NULL;2988struct merge_file_info mfi;2989struct diff_filespec one, a, b;2990unsigned df_conflict_remains =0;29912992if(!o_oid) {2993 reason =_("add/add");2994 o_oid = (struct object_id *)&null_oid;2995}2996 one.path = a.path = b.path = (char*)path;2997oidcpy(&one.oid, o_oid);2998 one.mode = o_mode;2999oidcpy(&a.oid, a_oid);3000 a.mode = a_mode;3001oidcpy(&b.oid, b_oid);3002 b.mode = b_mode;30033004if(rename_conflict_info) {3005struct diff_filepair *pair1 = rename_conflict_info->pair1;30063007 path1 = (o->branch1 == rename_conflict_info->branch1) ?3008 pair1->two->path : pair1->one->path;3009/* If rename_conflict_info->pair2 != NULL, we are in3010 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a3011 * normal rename.3012 */3013 path2 = (rename_conflict_info->pair2 ||3014 o->branch2 == rename_conflict_info->branch1) ?3015 pair1->two->path : pair1->one->path;3016 one.path = pair1->one->path;3017 a.path = (char*)path1;3018 b.path = (char*)path2;30193020if(dir_in_way(path, !o->call_depth,3021S_ISGITLINK(pair1->two->mode)))3022 df_conflict_remains =1;3023}3024if(merge_mode_and_contents(o, &one, &a, &b, path,3025 o->branch1, o->branch2, &mfi))3026return-1;30273028/*3029 * We can skip updating the working tree file iff:3030 * a) The merge is clean3031 * b) The merge matches what was in HEAD (content, mode, pathname)3032 * c) The target path is usable (i.e. not involved in D/F conflict)3033 */3034if(mfi.clean &&3035was_tracked_and_matches(o, path, &mfi.oid, mfi.mode) &&3036!df_conflict_remains) {3037int pos;3038struct cache_entry *ce;30393040output(o,3,_("Skipped%s(merged same as existing)"), path);3041if(add_cacheinfo(o, mfi.mode, &mfi.oid, path,30420, (!o->call_depth && !is_dirty),0))3043return-1;3044/*3045 * However, add_cacheinfo() will delete the old cache entry3046 * and add a new one. We need to copy over any skip_worktree3047 * flag to avoid making the file appear as if it were3048 * deleted by the user.3049 */3050 pos =index_name_pos(&o->orig_index, path,strlen(path));3051 ce = o->orig_index.cache[pos];3052if(ce_skip_worktree(ce)) {3053 pos =index_name_pos(&the_index, path,strlen(path));3054 ce = the_index.cache[pos];3055 ce->ce_flags |= CE_SKIP_WORKTREE;3056}3057return mfi.clean;3058}30593060if(!mfi.clean) {3061if(S_ISGITLINK(mfi.mode))3062 reason =_("submodule");3063output(o,1,_("CONFLICT (%s): Merge conflict in%s"),3064 reason, path);3065if(rename_conflict_info && !df_conflict_remains)3066if(update_stages(o, path, &one, &a, &b))3067return-1;3068}30693070if(df_conflict_remains || is_dirty) {3071char*new_path;3072if(o->call_depth) {3073remove_file_from_cache(path);3074}else{3075if(!mfi.clean) {3076if(update_stages(o, path, &one, &a, &b))3077return-1;3078}else{3079int file_from_stage2 =was_tracked(o, path);3080struct diff_filespec merged;3081oidcpy(&merged.oid, &mfi.oid);3082 merged.mode = mfi.mode;30833084if(update_stages(o, path, NULL,3085 file_from_stage2 ? &merged : NULL,3086 file_from_stage2 ? NULL : &merged))3087return-1;3088}30893090}3091 new_path =unique_path(o, path, rename_conflict_info->branch1);3092if(is_dirty) {3093output(o,1,_("Refusing to lose dirty file at%s"),3094 path);3095}3096output(o,1,_("Adding as%sinstead"), new_path);3097if(update_file(o,0, &mfi.oid, mfi.mode, new_path)) {3098free(new_path);3099return-1;3100}3101free(new_path);3102 mfi.clean =0;3103}else if(update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))3104return-1;3105return!is_dirty && mfi.clean;3106}31073108static inthandle_rename_normal(struct merge_options *o,3109const char*path,3110struct object_id *o_oid,unsigned int o_mode,3111struct object_id *a_oid,unsigned int a_mode,3112struct object_id *b_oid,unsigned int b_mode,3113struct rename_conflict_info *ci)3114{3115/* Merge the content and write it out */3116returnhandle_content_merge(o, path,was_dirty(o, path),3117 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3118 ci);3119}31203121/* Per entry merge function */3122static intprocess_entry(struct merge_options *o,3123const char*path,struct stage_data *entry)3124{3125int clean_merge =1;3126int normalize = o->renormalize;3127unsigned o_mode = entry->stages[1].mode;3128unsigned a_mode = entry->stages[2].mode;3129unsigned b_mode = entry->stages[3].mode;3130struct object_id *o_oid =stage_oid(&entry->stages[1].oid, o_mode);3131struct object_id *a_oid =stage_oid(&entry->stages[2].oid, a_mode);3132struct object_id *b_oid =stage_oid(&entry->stages[3].oid, b_mode);31333134 entry->processed =1;3135if(entry->rename_conflict_info) {3136struct rename_conflict_info *conflict_info = entry->rename_conflict_info;3137switch(conflict_info->rename_type) {3138case RENAME_NORMAL:3139case RENAME_ONE_FILE_TO_ONE:3140 clean_merge =handle_rename_normal(o,3141 path,3142 o_oid, o_mode,3143 a_oid, a_mode,3144 b_oid, b_mode,3145 conflict_info);3146break;3147case RENAME_VIA_DIR:3148 clean_merge =1;3149if(handle_rename_via_dir(o,3150 conflict_info->pair1,3151 conflict_info->branch1,3152 conflict_info->branch2))3153 clean_merge = -1;3154break;3155case RENAME_DELETE:3156 clean_merge =0;3157if(handle_rename_delete(o,3158 conflict_info->pair1,3159 conflict_info->branch1,3160 conflict_info->branch2))3161 clean_merge = -1;3162break;3163case RENAME_ONE_FILE_TO_TWO:3164 clean_merge =0;3165if(handle_rename_rename_1to2(o, conflict_info))3166 clean_merge = -1;3167break;3168case RENAME_TWO_FILES_TO_ONE:3169 clean_merge =0;3170if(handle_rename_rename_2to1(o, conflict_info))3171 clean_merge = -1;3172break;3173default:3174 entry->processed =0;3175break;3176}3177}else if(o_oid && (!a_oid || !b_oid)) {3178/* Case A: Deleted in one */3179if((!a_oid && !b_oid) ||3180(!b_oid &&blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||3181(!a_oid &&blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {3182/* Deleted in both or deleted in one and3183 * unchanged in the other */3184if(a_oid)3185output(o,2,_("Removing%s"), path);3186/* do not touch working file if it did not exist */3187remove_file(o,1, path, !a_oid);3188}else{3189/* Modify/delete; deleted side may have put a directory in the way */3190 clean_merge =0;3191if(handle_modify_delete(o, path, o_oid, o_mode,3192 a_oid, a_mode, b_oid, b_mode))3193 clean_merge = -1;3194}3195}else if((!o_oid && a_oid && !b_oid) ||3196(!o_oid && !a_oid && b_oid)) {3197/* Case B: Added in one. */3198/* [nothing|directory] -> ([nothing|directory], file) */31993200const char*add_branch;3201const char*other_branch;3202unsigned mode;3203const struct object_id *oid;3204const char*conf;32053206if(a_oid) {3207 add_branch = o->branch1;3208 other_branch = o->branch2;3209 mode = a_mode;3210 oid = a_oid;3211 conf =_("file/directory");3212}else{3213 add_branch = o->branch2;3214 other_branch = o->branch1;3215 mode = b_mode;3216 oid = b_oid;3217 conf =_("directory/file");3218}3219if(dir_in_way(path,3220!o->call_depth && !S_ISGITLINK(a_mode),32210)) {3222char*new_path =unique_path(o, path, add_branch);3223 clean_merge =0;3224output(o,1,_("CONFLICT (%s): There is a directory with name%sin%s. "3225"Adding%sas%s"),3226 conf, path, other_branch, path, new_path);3227if(update_file(o,0, oid, mode, new_path))3228 clean_merge = -1;3229else if(o->call_depth)3230remove_file_from_cache(path);3231free(new_path);3232}else{3233output(o,2,_("Adding%s"), path);3234/* do not overwrite file if already present */3235if(update_file_flags(o, oid, mode, path,1, !a_oid))3236 clean_merge = -1;3237}3238}else if(a_oid && b_oid) {3239/* Case C: Added in both (check for same permissions) and */3240/* case D: Modified in both, but differently. */3241int is_dirty =0;/* unpack_trees would have bailed if dirty */3242 clean_merge =handle_content_merge(o, path, is_dirty,3243 o_oid, o_mode,3244 a_oid, a_mode,3245 b_oid, b_mode,3246 NULL);3247}else if(!o_oid && !a_oid && !b_oid) {3248/*3249 * this entry was deleted altogether. a_mode == 0 means3250 * we had that path and want to actively remove it.3251 */3252remove_file(o,1, path, !a_mode);3253}else3254BUG("fatal merge failure, shouldn't happen.");32553256return clean_merge;3257}32583259intmerge_trees(struct merge_options *o,3260struct tree *head,3261struct tree *merge,3262struct tree *common,3263struct tree **result)3264{3265int code, clean;3266struct strbuf sb = STRBUF_INIT;32673268if(!o->call_depth &&index_has_changes(&the_index, head, &sb)) {3269err(o,_("Your local changes to the following files would be overwritten by merge:\n%s"),3270 sb.buf);3271return-1;3272}32733274if(o->subtree_shift) {3275 merge =shift_tree_object(head, merge, o->subtree_shift);3276 common =shift_tree_object(head, common, o->subtree_shift);3277}32783279if(oid_eq(&common->object.oid, &merge->object.oid)) {3280output(o,0,_("Already up to date!"));3281*result = head;3282return1;3283}32843285 code =unpack_trees_start(o, common, head, merge);32863287if(code !=0) {3288if(show(o,4) || o->call_depth)3289err(o,_("merging of trees%sand%sfailed"),3290oid_to_hex(&head->object.oid),3291oid_to_hex(&merge->object.oid));3292unpack_trees_finish(o);3293return-1;3294}32953296if(unmerged_cache()) {3297struct string_list *entries;3298struct rename_info re_info;3299int i;3300/*3301 * Only need the hashmap while processing entries, so3302 * initialize it here and free it when we are done running3303 * through the entries. Keeping it in the merge_options as3304 * opposed to decaring a local hashmap is for convenience3305 * so that we don't have to pass it to around.3306 */3307hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL,512);3308get_files_dirs(o, head);3309get_files_dirs(o, merge);33103311 entries =get_unmerged();3312 clean =detect_and_process_renames(o, common, head, merge,3313 entries, &re_info);3314record_df_conflict_files(o, entries);3315if(clean <0)3316goto cleanup;3317for(i = entries->nr-1;0<= i; i--) {3318const char*path = entries->items[i].string;3319struct stage_data *e = entries->items[i].util;3320if(!e->processed) {3321int ret =process_entry(o, path, e);3322if(!ret)3323 clean =0;3324else if(ret <0) {3325 clean = ret;3326goto cleanup;3327}3328}3329}3330for(i =0; i < entries->nr; i++) {3331struct stage_data *e = entries->items[i].util;3332if(!e->processed)3333BUG("unprocessed path???%s",3334 entries->items[i].string);3335}33363337 cleanup:3338final_cleanup_renames(&re_info);33393340string_list_clear(entries,1);3341free(entries);33423343hashmap_free(&o->current_file_dir_set,1);33443345if(clean <0) {3346unpack_trees_finish(o);3347return clean;3348}3349}3350else3351 clean =1;33523353unpack_trees_finish(o);33543355if(o->call_depth && !(*result =write_tree_from_memory(o)))3356return-1;33573358return clean;3359}33603361static struct commit_list *reverse_commit_list(struct commit_list *list)3362{3363struct commit_list *next = NULL, *current, *backup;3364for(current = list; current; current = backup) {3365 backup = current->next;3366 current->next = next;3367 next = current;3368}3369return next;3370}33713372/*3373 * Merge the commits h1 and h2, return the resulting virtual3374 * commit object and a flag indicating the cleanness of the merge.3375 */3376intmerge_recursive(struct merge_options *o,3377struct commit *h1,3378struct commit *h2,3379struct commit_list *ca,3380struct commit **result)3381{3382struct commit_list *iter;3383struct commit *merged_common_ancestors;3384struct tree *mrtree;3385int clean;33863387if(show(o,4)) {3388output(o,4,_("Merging:"));3389output_commit_title(o, h1);3390output_commit_title(o, h2);3391}33923393if(!ca) {3394 ca =get_merge_bases(h1, h2);3395 ca =reverse_commit_list(ca);3396}33973398if(show(o,5)) {3399unsigned cnt =commit_list_count(ca);34003401output(o,5,Q_("found%ucommon ancestor:",3402"found%ucommon ancestors:", cnt), cnt);3403for(iter = ca; iter; iter = iter->next)3404output_commit_title(o, iter->item);3405}34063407 merged_common_ancestors =pop_commit(&ca);3408if(merged_common_ancestors == NULL) {3409/* if there is no common ancestor, use an empty tree */3410struct tree *tree;34113412 tree =lookup_tree(the_repository, the_repository->hash_algo->empty_tree);3413 merged_common_ancestors =make_virtual_commit(tree,"ancestor");3414}34153416for(iter = ca; iter; iter = iter->next) {3417const char*saved_b1, *saved_b2;3418 o->call_depth++;3419/*3420 * When the merge fails, the result contains files3421 * with conflict markers. The cleanness flag is3422 * ignored (unless indicating an error), it was never3423 * actually used, as result of merge_trees has always3424 * overwritten it: the committed "conflicts" were3425 * already resolved.3426 */3427discard_cache();3428 saved_b1 = o->branch1;3429 saved_b2 = o->branch2;3430 o->branch1 ="Temporary merge branch 1";3431 o->branch2 ="Temporary merge branch 2";3432if(merge_recursive(o, merged_common_ancestors, iter->item,3433 NULL, &merged_common_ancestors) <0)3434return-1;3435 o->branch1 = saved_b1;3436 o->branch2 = saved_b2;3437 o->call_depth--;34383439if(!merged_common_ancestors)3440returnerr(o,_("merge returned no commit"));3441}34423443discard_cache();3444if(!o->call_depth)3445read_cache();34463447 o->ancestor ="merged common ancestors";3448 clean =merge_trees(o,get_commit_tree(h1),get_commit_tree(h2),3449get_commit_tree(merged_common_ancestors),3450&mrtree);3451if(clean <0) {3452flush_output(o);3453return clean;3454}34553456if(o->call_depth) {3457*result =make_virtual_commit(mrtree,"merged tree");3458commit_list_insert(h1, &(*result)->parents);3459commit_list_insert(h2, &(*result)->parents->next);3460}3461flush_output(o);3462if(!o->call_depth && o->buffer_output <2)3463strbuf_release(&o->obuf);3464if(show(o,2))3465diff_warn_rename_limit("merge.renamelimit",3466 o->needed_rename_limit,0);3467return clean;3468}34693470static struct commit *get_ref(const struct object_id *oid,const char*name)3471{3472struct object *object;34733474 object =deref_tag(the_repository,parse_object(the_repository, oid),3475 name,3476strlen(name));3477if(!object)3478return NULL;3479if(object->type == OBJ_TREE)3480returnmake_virtual_commit((struct tree*)object, name);3481if(object->type != OBJ_COMMIT)3482return NULL;3483if(parse_commit((struct commit *)object))3484return NULL;3485return(struct commit *)object;3486}34873488intmerge_recursive_generic(struct merge_options *o,3489const struct object_id *head,3490const struct object_id *merge,3491int num_base_list,3492const struct object_id **base_list,3493struct commit **result)3494{3495int clean;3496struct lock_file lock = LOCK_INIT;3497struct commit *head_commit =get_ref(head, o->branch1);3498struct commit *next_commit =get_ref(merge, o->branch2);3499struct commit_list *ca = NULL;35003501if(base_list) {3502int i;3503for(i =0; i < num_base_list; ++i) {3504struct commit *base;3505if(!(base =get_ref(base_list[i],oid_to_hex(base_list[i]))))3506returnerr(o,_("Could not parse object '%s'"),3507oid_to_hex(base_list[i]));3508commit_list_insert(base, &ca);3509}3510}35113512hold_locked_index(&lock, LOCK_DIE_ON_ERROR);3513 clean =merge_recursive(o, head_commit, next_commit, ca,3514 result);3515if(clean <0) {3516rollback_lock_file(&lock);3517return clean;3518}35193520if(write_locked_index(&the_index, &lock,3521 COMMIT_LOCK | SKIP_IF_UNCHANGED))3522returnerr(o,_("Unable to write index."));35233524return clean ?0:1;3525}35263527static voidmerge_recursive_config(struct merge_options *o)3528{3529char*value = NULL;3530git_config_get_int("merge.verbosity", &o->verbosity);3531git_config_get_int("diff.renamelimit", &o->diff_rename_limit);3532git_config_get_int("merge.renamelimit", &o->merge_rename_limit);3533if(!git_config_get_string("diff.renames", &value)) {3534 o->diff_detect_rename =git_config_rename("diff.renames", value);3535free(value);3536}3537if(!git_config_get_string("merge.renames", &value)) {3538 o->merge_detect_rename =git_config_rename("merge.renames", value);3539free(value);3540}3541git_config(git_xmerge_config, NULL);3542}35433544voidinit_merge_options(struct merge_options *o)3545{3546const char*merge_verbosity;3547memset(o,0,sizeof(struct merge_options));3548 o->verbosity =2;3549 o->buffer_output =1;3550 o->diff_rename_limit = -1;3551 o->merge_rename_limit = -1;3552 o->renormalize =0;3553 o->diff_detect_rename = -1;3554 o->merge_detect_rename = -1;3555 o->detect_directory_renames =1;3556merge_recursive_config(o);3557 merge_verbosity =getenv("GIT_MERGE_VERBOSITY");3558if(merge_verbosity)3559 o->verbosity =strtol(merge_verbosity, NULL,10);3560if(o->verbosity >=5)3561 o->buffer_output =0;3562strbuf_init(&o->obuf,0);3563string_list_init(&o->df_conflict_file_set,1);3564}35653566intparse_merge_opt(struct merge_options *o,const char*s)3567{3568const char*arg;35693570if(!s || !*s)3571return-1;3572if(!strcmp(s,"ours"))3573 o->recursive_variant = MERGE_RECURSIVE_OURS;3574else if(!strcmp(s,"theirs"))3575 o->recursive_variant = MERGE_RECURSIVE_THEIRS;3576else if(!strcmp(s,"subtree"))3577 o->subtree_shift ="";3578else if(skip_prefix(s,"subtree=", &arg))3579 o->subtree_shift = arg;3580else if(!strcmp(s,"patience"))3581 o->xdl_opts =DIFF_WITH_ALG(o, PATIENCE_DIFF);3582else if(!strcmp(s,"histogram"))3583 o->xdl_opts =DIFF_WITH_ALG(o, HISTOGRAM_DIFF);3584else if(skip_prefix(s,"diff-algorithm=", &arg)) {3585long value =parse_algorithm_value(arg);3586if(value <0)3587return-1;3588/* clear out previous settings */3589DIFF_XDL_CLR(o, NEED_MINIMAL);3590 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3591 o->xdl_opts |= value;3592}3593else if(!strcmp(s,"ignore-space-change"))3594DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);3595else if(!strcmp(s,"ignore-all-space"))3596DIFF_XDL_SET(o, IGNORE_WHITESPACE);3597else if(!strcmp(s,"ignore-space-at-eol"))3598DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);3599else if(!strcmp(s,"ignore-cr-at-eol"))3600DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);3601else if(!strcmp(s,"renormalize"))3602 o->renormalize =1;3603else if(!strcmp(s,"no-renormalize"))3604 o->renormalize =0;3605else if(!strcmp(s,"no-renames"))3606 o->merge_detect_rename =0;3607else if(!strcmp(s,"find-renames")) {3608 o->merge_detect_rename =1;3609 o->rename_score =0;3610}3611else if(skip_prefix(s,"find-renames=", &arg) ||3612skip_prefix(s,"rename-threshold=", &arg)) {3613if((o->rename_score =parse_rename_score(&arg)) == -1|| *arg !=0)3614return-1;3615 o->merge_detect_rename =1;3616}3617else3618return-1;3619return0;3620}