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"commit.h" 12#include"blob.h" 13#include"builtin.h" 14#include"tree-walk.h" 15#include"diff.h" 16#include"diffcore.h" 17#include"tag.h" 18#include"unpack-trees.h" 19#include"string-list.h" 20#include"xdiff-interface.h" 21#include"ll-merge.h" 22#include"attr.h" 23#include"merge-recursive.h" 24#include"dir.h" 25#include"submodule.h" 26 27struct path_hashmap_entry { 28struct hashmap_entry e; 29char path[FLEX_ARRAY]; 30}; 31 32static intpath_hashmap_cmp(const void*cmp_data, 33const void*entry, 34const void*entry_or_key, 35const void*keydata) 36{ 37const struct path_hashmap_entry *a = entry; 38const struct path_hashmap_entry *b = entry_or_key; 39const char*key = keydata; 40 41if(ignore_case) 42returnstrcasecmp(a->path, key ? key : b->path); 43else 44returnstrcmp(a->path, key ? key : b->path); 45} 46 47static unsigned intpath_hash(const char*path) 48{ 49return ignore_case ?strihash(path) :strhash(path); 50} 51 52static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap, 53char*dir) 54{ 55struct dir_rename_entry key; 56 57if(dir == NULL) 58return NULL; 59hashmap_entry_init(&key,strhash(dir)); 60 key.dir = dir; 61returnhashmap_get(hashmap, &key, NULL); 62} 63 64static intdir_rename_cmp(const void*unused_cmp_data, 65const void*entry, 66const void*entry_or_key, 67const void*unused_keydata) 68{ 69const struct dir_rename_entry *e1 = entry; 70const struct dir_rename_entry *e2 = entry_or_key; 71 72returnstrcmp(e1->dir, e2->dir); 73} 74 75static voiddir_rename_init(struct hashmap *map) 76{ 77hashmap_init(map, dir_rename_cmp, NULL,0); 78} 79 80static voiddir_rename_entry_init(struct dir_rename_entry *entry, 81char*directory) 82{ 83hashmap_entry_init(entry,strhash(directory)); 84 entry->dir = directory; 85 entry->non_unique_new_dir =0; 86strbuf_init(&entry->new_dir,0); 87string_list_init(&entry->possible_new_dirs,0); 88} 89 90static struct collision_entry *collision_find_entry(struct hashmap *hashmap, 91char*target_file) 92{ 93struct collision_entry key; 94 95hashmap_entry_init(&key,strhash(target_file)); 96 key.target_file = target_file; 97returnhashmap_get(hashmap, &key, NULL); 98} 99 100static intcollision_cmp(void*unused_cmp_data, 101const struct collision_entry *e1, 102const struct collision_entry *e2, 103const void*unused_keydata) 104{ 105returnstrcmp(e1->target_file, e2->target_file); 106} 107 108static voidcollision_init(struct hashmap *map) 109{ 110hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL,0); 111} 112 113static voidflush_output(struct merge_options *o) 114{ 115if(o->buffer_output <2&& o->obuf.len) { 116fputs(o->obuf.buf, stdout); 117strbuf_reset(&o->obuf); 118} 119} 120 121static interr(struct merge_options *o,const char*err, ...) 122{ 123va_list params; 124 125if(o->buffer_output <2) 126flush_output(o); 127else{ 128strbuf_complete(&o->obuf,'\n'); 129strbuf_addstr(&o->obuf,"error: "); 130} 131va_start(params, err); 132strbuf_vaddf(&o->obuf, err, params); 133va_end(params); 134if(o->buffer_output >1) 135strbuf_addch(&o->obuf,'\n'); 136else{ 137error("%s", o->obuf.buf); 138strbuf_reset(&o->obuf); 139} 140 141return-1; 142} 143 144static struct tree *shift_tree_object(struct tree *one,struct tree *two, 145const char*subtree_shift) 146{ 147struct object_id shifted; 148 149if(!*subtree_shift) { 150shift_tree(&one->object.oid, &two->object.oid, &shifted,0); 151}else{ 152shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 153 subtree_shift); 154} 155if(!oidcmp(&two->object.oid, &shifted)) 156return two; 157returnlookup_tree(&shifted); 158} 159 160static struct commit *make_virtual_commit(struct tree *tree,const char*comment) 161{ 162struct commit *commit =alloc_commit_node(); 163 164set_merge_remote_desc(commit, comment, (struct object *)commit); 165 commit->tree = tree; 166 commit->object.parsed =1; 167return commit; 168} 169 170/* 171 * Since we use get_tree_entry(), which does not put the read object into 172 * the object pool, we cannot rely on a == b. 173 */ 174static intoid_eq(const struct object_id *a,const struct object_id *b) 175{ 176if(!a && !b) 177return2; 178return a && b &&oidcmp(a, b) ==0; 179} 180 181enum rename_type { 182 RENAME_NORMAL =0, 183 RENAME_DIR, 184 RENAME_DELETE, 185 RENAME_ONE_FILE_TO_ONE, 186 RENAME_ONE_FILE_TO_TWO, 187 RENAME_TWO_FILES_TO_ONE 188}; 189 190struct rename_conflict_info { 191enum rename_type rename_type; 192struct diff_filepair *pair1; 193struct diff_filepair *pair2; 194const char*branch1; 195const char*branch2; 196struct stage_data *dst_entry1; 197struct stage_data *dst_entry2; 198struct diff_filespec ren1_other; 199struct diff_filespec ren2_other; 200}; 201 202/* 203 * Since we want to write the index eventually, we cannot reuse the index 204 * for these (temporary) data. 205 */ 206struct stage_data { 207struct{ 208unsigned mode; 209struct object_id oid; 210} stages[4]; 211struct rename_conflict_info *rename_conflict_info; 212unsigned processed:1; 213}; 214 215staticinlinevoidsetup_rename_conflict_info(enum rename_type rename_type, 216struct diff_filepair *pair1, 217struct diff_filepair *pair2, 218const char*branch1, 219const char*branch2, 220struct stage_data *dst_entry1, 221struct stage_data *dst_entry2, 222struct merge_options *o, 223struct stage_data *src_entry1, 224struct stage_data *src_entry2) 225{ 226struct rename_conflict_info *ci =xcalloc(1,sizeof(struct rename_conflict_info)); 227 ci->rename_type = rename_type; 228 ci->pair1 = pair1; 229 ci->branch1 = branch1; 230 ci->branch2 = branch2; 231 232 ci->dst_entry1 = dst_entry1; 233 dst_entry1->rename_conflict_info = ci; 234 dst_entry1->processed =0; 235 236assert(!pair2 == !dst_entry2); 237if(dst_entry2) { 238 ci->dst_entry2 = dst_entry2; 239 ci->pair2 = pair2; 240 dst_entry2->rename_conflict_info = ci; 241} 242 243if(rename_type == RENAME_TWO_FILES_TO_ONE) { 244/* 245 * For each rename, there could have been 246 * modifications on the side of history where that 247 * file was not renamed. 248 */ 249int ostage1 = o->branch1 == branch1 ?3:2; 250int ostage2 = ostage1 ^1; 251 252 ci->ren1_other.path = pair1->one->path; 253oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid); 254 ci->ren1_other.mode = src_entry1->stages[ostage1].mode; 255 256 ci->ren2_other.path = pair2->one->path; 257oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid); 258 ci->ren2_other.mode = src_entry2->stages[ostage2].mode; 259} 260} 261 262static intshow(struct merge_options *o,int v) 263{ 264return(!o->call_depth && o->verbosity >= v) || o->verbosity >=5; 265} 266 267__attribute__((format(printf,3,4))) 268static voidoutput(struct merge_options *o,int v,const char*fmt, ...) 269{ 270va_list ap; 271 272if(!show(o, v)) 273return; 274 275strbuf_addchars(&o->obuf,' ', o->call_depth *2); 276 277va_start(ap, fmt); 278strbuf_vaddf(&o->obuf, fmt, ap); 279va_end(ap); 280 281strbuf_addch(&o->obuf,'\n'); 282if(!o->buffer_output) 283flush_output(o); 284} 285 286static voidoutput_commit_title(struct merge_options *o,struct commit *commit) 287{ 288strbuf_addchars(&o->obuf,' ', o->call_depth *2); 289if(commit->util) 290strbuf_addf(&o->obuf,"virtual%s\n", 291merge_remote_util(commit)->name); 292else{ 293strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid, 294 DEFAULT_ABBREV); 295strbuf_addch(&o->obuf,' '); 296if(parse_commit(commit) !=0) 297strbuf_addstr(&o->obuf,_("(bad commit)\n")); 298else{ 299const char*title; 300const char*msg =get_commit_buffer(commit, NULL); 301int len =find_commit_subject(msg, &title); 302if(len) 303strbuf_addf(&o->obuf,"%.*s\n", len, title); 304unuse_commit_buffer(commit, msg); 305} 306} 307flush_output(o); 308} 309 310static intadd_cacheinfo(struct merge_options *o, 311unsigned int mode,const struct object_id *oid, 312const char*path,int stage,int refresh,int options) 313{ 314struct cache_entry *ce; 315int ret; 316 317 ce =make_cache_entry(mode, oid ? oid->hash : null_sha1, path, stage,0); 318if(!ce) 319returnerr(o,_("add_cacheinfo failed for path '%s'; merge aborting."), path); 320 321 ret =add_cache_entry(ce, options); 322if(refresh) { 323struct cache_entry *nce; 324 325 nce =refresh_cache_entry(ce, CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 326if(!nce) 327returnerr(o,_("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); 328if(nce != ce) 329 ret =add_cache_entry(nce, options); 330} 331return ret; 332} 333 334static voidinit_tree_desc_from_tree(struct tree_desc *desc,struct tree *tree) 335{ 336parse_tree(tree); 337init_tree_desc(desc, tree->buffer, tree->size); 338} 339 340static intgit_merge_trees(struct merge_options *o, 341struct tree *common, 342struct tree *head, 343struct tree *merge) 344{ 345int rc; 346struct tree_desc t[3]; 347struct index_state tmp_index = { NULL }; 348 349memset(&o->unpack_opts,0,sizeof(o->unpack_opts)); 350if(o->call_depth) 351 o->unpack_opts.index_only =1; 352else 353 o->unpack_opts.update =1; 354 o->unpack_opts.merge =1; 355 o->unpack_opts.head_idx =2; 356 o->unpack_opts.fn = threeway_merge; 357 o->unpack_opts.src_index = &the_index; 358 o->unpack_opts.dst_index = &tmp_index; 359setup_unpack_trees_porcelain(&o->unpack_opts,"merge"); 360 361init_tree_desc_from_tree(t+0, common); 362init_tree_desc_from_tree(t+1, head); 363init_tree_desc_from_tree(t+2, merge); 364 365 rc =unpack_trees(3, t, &o->unpack_opts); 366cache_tree_free(&active_cache_tree); 367 368/* 369 * Update the_index to match the new results, AFTER saving a copy 370 * in o->orig_index. Update src_index to point to the saved copy. 371 * (verify_uptodate() checks src_index, and the original index is 372 * the one that had the necessary modification timestamps.) 373 */ 374 o->orig_index = the_index; 375 the_index = tmp_index; 376 o->unpack_opts.src_index = &o->orig_index; 377 378return rc; 379} 380 381struct tree *write_tree_from_memory(struct merge_options *o) 382{ 383struct tree *result = NULL; 384 385if(unmerged_cache()) { 386int i; 387fprintf(stderr,"BUG: There are unmerged index entries:\n"); 388for(i =0; i < active_nr; i++) { 389const struct cache_entry *ce = active_cache[i]; 390if(ce_stage(ce)) 391fprintf(stderr,"BUG:%d%.*s\n",ce_stage(ce), 392(int)ce_namelen(ce), ce->name); 393} 394die("BUG: unmerged index entries in merge-recursive.c"); 395} 396 397if(!active_cache_tree) 398 active_cache_tree =cache_tree(); 399 400if(!cache_tree_fully_valid(active_cache_tree) && 401cache_tree_update(&the_index,0) <0) { 402err(o,_("error building trees")); 403return NULL; 404} 405 406 result =lookup_tree(&active_cache_tree->oid); 407 408return result; 409} 410 411static intsave_files_dirs(const struct object_id *oid, 412struct strbuf *base,const char*path, 413unsigned int mode,int stage,void*context) 414{ 415struct path_hashmap_entry *entry; 416int baselen = base->len; 417struct merge_options *o = context; 418 419strbuf_addstr(base, path); 420 421FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 422hashmap_entry_init(entry,path_hash(entry->path)); 423hashmap_add(&o->current_file_dir_set, entry); 424 425strbuf_setlen(base, baselen); 426return(S_ISDIR(mode) ? READ_TREE_RECURSIVE :0); 427} 428 429static voidget_files_dirs(struct merge_options *o,struct tree *tree) 430{ 431struct pathspec match_all; 432memset(&match_all,0,sizeof(match_all)); 433read_tree_recursive(tree,"",0,0, &match_all, save_files_dirs, o); 434} 435 436static intget_tree_entry_if_blob(const struct object_id *tree, 437const char*path, 438struct object_id *hashy, 439unsigned int*mode_o) 440{ 441int ret; 442 443 ret =get_tree_entry(tree, path, hashy, mode_o); 444if(S_ISDIR(*mode_o)) { 445oidcpy(hashy, &null_oid); 446*mode_o =0; 447} 448return ret; 449} 450 451/* 452 * Returns an index_entry instance which doesn't have to correspond to 453 * a real cache entry in Git's index. 454 */ 455static struct stage_data *insert_stage_data(const char*path, 456struct tree *o,struct tree *a,struct tree *b, 457struct string_list *entries) 458{ 459struct string_list_item *item; 460struct stage_data *e =xcalloc(1,sizeof(struct stage_data)); 461get_tree_entry_if_blob(&o->object.oid, path, 462&e->stages[1].oid, &e->stages[1].mode); 463get_tree_entry_if_blob(&a->object.oid, path, 464&e->stages[2].oid, &e->stages[2].mode); 465get_tree_entry_if_blob(&b->object.oid, path, 466&e->stages[3].oid, &e->stages[3].mode); 467 item =string_list_insert(entries, path); 468 item->util = e; 469return e; 470} 471 472/* 473 * Create a dictionary mapping file names to stage_data objects. The 474 * dictionary contains one entry for every path with a non-zero stage entry. 475 */ 476static struct string_list *get_unmerged(void) 477{ 478struct string_list *unmerged =xcalloc(1,sizeof(struct string_list)); 479int i; 480 481 unmerged->strdup_strings =1; 482 483for(i =0; i < active_nr; i++) { 484struct string_list_item *item; 485struct stage_data *e; 486const struct cache_entry *ce = active_cache[i]; 487if(!ce_stage(ce)) 488continue; 489 490 item =string_list_lookup(unmerged, ce->name); 491if(!item) { 492 item =string_list_insert(unmerged, ce->name); 493 item->util =xcalloc(1,sizeof(struct stage_data)); 494} 495 e = item->util; 496 e->stages[ce_stage(ce)].mode = ce->ce_mode; 497oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 498} 499 500return unmerged; 501} 502 503static intstring_list_df_name_compare(const char*one,const char*two) 504{ 505int onelen =strlen(one); 506int twolen =strlen(two); 507/* 508 * Here we only care that entries for D/F conflicts are 509 * adjacent, in particular with the file of the D/F conflict 510 * appearing before files below the corresponding directory. 511 * The order of the rest of the list is irrelevant for us. 512 * 513 * To achieve this, we sort with df_name_compare and provide 514 * the mode S_IFDIR so that D/F conflicts will sort correctly. 515 * We use the mode S_IFDIR for everything else for simplicity, 516 * since in other cases any changes in their order due to 517 * sorting cause no problems for us. 518 */ 519int cmp =df_name_compare(one, onelen, S_IFDIR, 520 two, twolen, S_IFDIR); 521/* 522 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 523 * that 'foo' comes before 'foo/bar'. 524 */ 525if(cmp) 526return cmp; 527return onelen - twolen; 528} 529 530static voidrecord_df_conflict_files(struct merge_options *o, 531struct string_list *entries) 532{ 533/* If there is a D/F conflict and the file for such a conflict 534 * currently exist in the working tree, we want to allow it to be 535 * removed to make room for the corresponding directory if needed. 536 * The files underneath the directories of such D/F conflicts will 537 * be processed before the corresponding file involved in the D/F 538 * conflict. If the D/F directory ends up being removed by the 539 * merge, then we won't have to touch the D/F file. If the D/F 540 * directory needs to be written to the working copy, then the D/F 541 * file will simply be removed (in make_room_for_path()) to make 542 * room for the necessary paths. Note that if both the directory 543 * and the file need to be present, then the D/F file will be 544 * reinstated with a new unique name at the time it is processed. 545 */ 546struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 547const char*last_file = NULL; 548int last_len =0; 549int i; 550 551/* 552 * If we're merging merge-bases, we don't want to bother with 553 * any working directory changes. 554 */ 555if(o->call_depth) 556return; 557 558/* Ensure D/F conflicts are adjacent in the entries list. */ 559for(i =0; i < entries->nr; i++) { 560struct string_list_item *next = &entries->items[i]; 561string_list_append(&df_sorted_entries, next->string)->util = 562 next->util; 563} 564 df_sorted_entries.cmp = string_list_df_name_compare; 565string_list_sort(&df_sorted_entries); 566 567string_list_clear(&o->df_conflict_file_set,1); 568for(i =0; i < df_sorted_entries.nr; i++) { 569const char*path = df_sorted_entries.items[i].string; 570int len =strlen(path); 571struct stage_data *e = df_sorted_entries.items[i].util; 572 573/* 574 * Check if last_file & path correspond to a D/F conflict; 575 * i.e. whether path is last_file+'/'+<something>. 576 * If so, record that it's okay to remove last_file to make 577 * room for path and friends if needed. 578 */ 579if(last_file && 580 len > last_len && 581memcmp(path, last_file, last_len) ==0&& 582 path[last_len] =='/') { 583string_list_insert(&o->df_conflict_file_set, last_file); 584} 585 586/* 587 * Determine whether path could exist as a file in the 588 * working directory as a possible D/F conflict. This 589 * will only occur when it exists in stage 2 as a 590 * file. 591 */ 592if(S_ISREG(e->stages[2].mode) ||S_ISLNK(e->stages[2].mode)) { 593 last_file = path; 594 last_len = len; 595}else{ 596 last_file = NULL; 597} 598} 599string_list_clear(&df_sorted_entries,0); 600} 601 602struct rename { 603struct diff_filepair *pair; 604/* 605 * Purpose of src_entry and dst_entry: 606 * 607 * If 'before' is renamed to 'after' then src_entry will contain 608 * the versions of 'before' from the merge_base, HEAD, and MERGE in 609 * stages 1, 2, and 3; dst_entry will contain the respective 610 * versions of 'after' in corresponding locations. Thus, we have a 611 * total of six modes and oids, though some will be null. (Stage 0 612 * is ignored; we're interested in handling conflicts.) 613 * 614 * Since we don't turn on break-rewrites by default, neither 615 * src_entry nor dst_entry can have all three of their stages have 616 * non-null oids, meaning at most four of the six will be non-null. 617 * Also, since this is a rename, both src_entry and dst_entry will 618 * have at least one non-null oid, meaning at least two will be 619 * non-null. Of the six oids, a typical rename will have three be 620 * non-null. Only two implies a rename/delete, and four implies a 621 * rename/add. 622 */ 623struct stage_data *src_entry; 624struct stage_data *dst_entry; 625unsigned add_turned_into_rename:1; 626unsigned processed:1; 627}; 628 629static intupdate_stages(struct merge_options *opt,const char*path, 630const struct diff_filespec *o, 631const struct diff_filespec *a, 632const struct diff_filespec *b) 633{ 634 635/* 636 * NOTE: It is usually a bad idea to call update_stages on a path 637 * before calling update_file on that same path, since it can 638 * sometimes lead to spurious "refusing to lose untracked file..." 639 * messages from update_file (via make_room_for path via 640 * would_lose_untracked). Instead, reverse the order of the calls 641 * (executing update_file first and then update_stages). 642 */ 643int clear =1; 644int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 645if(clear) 646if(remove_file_from_cache(path)) 647return-1; 648if(o) 649if(add_cacheinfo(opt, o->mode, &o->oid, path,1,0, options)) 650return-1; 651if(a) 652if(add_cacheinfo(opt, a->mode, &a->oid, path,2,0, options)) 653return-1; 654if(b) 655if(add_cacheinfo(opt, b->mode, &b->oid, path,3,0, options)) 656return-1; 657return0; 658} 659 660static intupdate_stages_for_stage_data(struct merge_options *opt, 661const char*path, 662const struct stage_data *stage_data) 663{ 664struct diff_filespec o, a, b; 665 666 o.mode = stage_data->stages[1].mode; 667oidcpy(&o.oid, &stage_data->stages[1].oid); 668 669 a.mode = stage_data->stages[2].mode; 670oidcpy(&a.oid, &stage_data->stages[2].oid); 671 672 b.mode = stage_data->stages[3].mode; 673oidcpy(&b.oid, &stage_data->stages[3].oid); 674 675returnupdate_stages(opt, path, 676is_null_oid(&o.oid) ? NULL : &o, 677is_null_oid(&a.oid) ? NULL : &a, 678is_null_oid(&b.oid) ? NULL : &b); 679} 680 681static voidupdate_entry(struct stage_data *entry, 682struct diff_filespec *o, 683struct diff_filespec *a, 684struct diff_filespec *b) 685{ 686 entry->processed =0; 687 entry->stages[1].mode = o->mode; 688 entry->stages[2].mode = a->mode; 689 entry->stages[3].mode = b->mode; 690oidcpy(&entry->stages[1].oid, &o->oid); 691oidcpy(&entry->stages[2].oid, &a->oid); 692oidcpy(&entry->stages[3].oid, &b->oid); 693} 694 695static intremove_file(struct merge_options *o,int clean, 696const char*path,int no_wd) 697{ 698int update_cache = o->call_depth || clean; 699int update_working_directory = !o->call_depth && !no_wd; 700 701if(update_cache) { 702if(remove_file_from_cache(path)) 703return-1; 704} 705if(update_working_directory) { 706if(ignore_case) { 707struct cache_entry *ce; 708 ce =cache_file_exists(path,strlen(path), ignore_case); 709if(ce &&ce_stage(ce) ==0&&strcmp(path, ce->name)) 710return0; 711} 712if(remove_path(path)) 713return-1; 714} 715return0; 716} 717 718/* add a string to a strbuf, but converting "/" to "_" */ 719static voidadd_flattened_path(struct strbuf *out,const char*s) 720{ 721size_t i = out->len; 722strbuf_addstr(out, s); 723for(; i < out->len; i++) 724if(out->buf[i] =='/') 725 out->buf[i] ='_'; 726} 727 728static char*unique_path(struct merge_options *o,const char*path,const char*branch) 729{ 730struct path_hashmap_entry *entry; 731struct strbuf newpath = STRBUF_INIT; 732int suffix =0; 733size_t base_len; 734 735strbuf_addf(&newpath,"%s~", path); 736add_flattened_path(&newpath, branch); 737 738 base_len = newpath.len; 739while(hashmap_get_from_hash(&o->current_file_dir_set, 740path_hash(newpath.buf), newpath.buf) || 741(!o->call_depth &&file_exists(newpath.buf))) { 742strbuf_setlen(&newpath, base_len); 743strbuf_addf(&newpath,"_%d", suffix++); 744} 745 746FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 747hashmap_entry_init(entry,path_hash(entry->path)); 748hashmap_add(&o->current_file_dir_set, entry); 749returnstrbuf_detach(&newpath, NULL); 750} 751 752/** 753 * Check whether a directory in the index is in the way of an incoming 754 * file. Return 1 if so. If check_working_copy is non-zero, also 755 * check the working directory. If empty_ok is non-zero, also return 756 * 0 in the case where the working-tree dir exists but is empty. 757 */ 758static intdir_in_way(const char*path,int check_working_copy,int empty_ok) 759{ 760int pos; 761struct strbuf dirpath = STRBUF_INIT; 762struct stat st; 763 764strbuf_addstr(&dirpath, path); 765strbuf_addch(&dirpath,'/'); 766 767 pos =cache_name_pos(dirpath.buf, dirpath.len); 768 769if(pos <0) 770 pos = -1- pos; 771if(pos < active_nr && 772!strncmp(dirpath.buf, active_cache[pos]->name, dirpath.len)) { 773strbuf_release(&dirpath); 774return1; 775} 776 777strbuf_release(&dirpath); 778return check_working_copy && !lstat(path, &st) &&S_ISDIR(st.st_mode) && 779!(empty_ok &&is_empty_dir(path)); 780} 781 782/* 783 * Returns whether path was tracked in the index before the merge started 784 */ 785static intwas_tracked(struct merge_options *o,const char*path) 786{ 787int pos =index_name_pos(&o->orig_index, path,strlen(path)); 788 789if(0<= pos) 790/* we were tracking this path before the merge */ 791return1; 792 793return0; 794} 795 796static intwould_lose_untracked(const char*path) 797{ 798/* 799 * This may look like it can be simplified to: 800 * return !was_tracked(o, path) && file_exists(path) 801 * but it can't. This function needs to know whether path was in 802 * the working tree due to EITHER having been tracked in the index 803 * before the merge OR having been put into the working copy and 804 * index by unpack_trees(). Due to that either-or requirement, we 805 * check the current index instead of the original one. 806 * 807 * Note that we do not need to worry about merge-recursive itself 808 * updating the index after unpack_trees() and before calling this 809 * function, because we strictly require all code paths in 810 * merge-recursive to update the working tree first and the index 811 * second. Doing otherwise would break 812 * update_file()/would_lose_untracked(); see every comment in this 813 * file which mentions "update_stages". 814 */ 815int pos =cache_name_pos(path,strlen(path)); 816 817if(pos <0) 818 pos = -1- pos; 819while(pos < active_nr && 820!strcmp(path, active_cache[pos]->name)) { 821/* 822 * If stage #0, it is definitely tracked. 823 * If it has stage #2 then it was tracked 824 * before this merge started. All other 825 * cases the path was not tracked. 826 */ 827switch(ce_stage(active_cache[pos])) { 828case0: 829case2: 830return0; 831} 832 pos++; 833} 834returnfile_exists(path); 835} 836 837static intwas_dirty(struct merge_options *o,const char*path) 838{ 839struct cache_entry *ce; 840int dirty =1; 841 842if(o->call_depth || !was_tracked(o, path)) 843return!dirty; 844 845 ce =index_file_exists(o->unpack_opts.src_index, 846 path,strlen(path), ignore_case); 847 dirty =verify_uptodate(ce, &o->unpack_opts) !=0; 848return dirty; 849} 850 851static intmake_room_for_path(struct merge_options *o,const char*path) 852{ 853int status, i; 854const char*msg =_("failed to create path '%s'%s"); 855 856/* Unlink any D/F conflict files that are in the way */ 857for(i =0; i < o->df_conflict_file_set.nr; i++) { 858const char*df_path = o->df_conflict_file_set.items[i].string; 859size_t pathlen =strlen(path); 860size_t df_pathlen =strlen(df_path); 861if(df_pathlen < pathlen && 862 path[df_pathlen] =='/'&& 863strncmp(path, df_path, df_pathlen) ==0) { 864output(o,3, 865_("Removing%sto make room for subdirectory\n"), 866 df_path); 867unlink(df_path); 868unsorted_string_list_delete_item(&o->df_conflict_file_set, 869 i,0); 870break; 871} 872} 873 874/* Make sure leading directories are created */ 875 status =safe_create_leading_directories_const(path); 876if(status) { 877if(status == SCLD_EXISTS) 878/* something else exists */ 879returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 880returnerr(o, msg, path,""); 881} 882 883/* 884 * Do not unlink a file in the work tree if we are not 885 * tracking it. 886 */ 887if(would_lose_untracked(path)) 888returnerr(o,_("refusing to lose untracked file at '%s'"), 889 path); 890 891/* Successful unlink is good.. */ 892if(!unlink(path)) 893return0; 894/* .. and so is no existing file */ 895if(errno == ENOENT) 896return0; 897/* .. but not some other error (who really cares what?) */ 898returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 899} 900 901static intupdate_file_flags(struct merge_options *o, 902const struct object_id *oid, 903unsigned mode, 904const char*path, 905int update_cache, 906int update_wd) 907{ 908int ret =0; 909 910if(o->call_depth) 911 update_wd =0; 912 913if(update_wd) { 914enum object_type type; 915void*buf; 916unsigned long size; 917 918if(S_ISGITLINK(mode)) { 919/* 920 * We may later decide to recursively descend into 921 * the submodule directory and update its index 922 * and/or work tree, but we do not do that now. 923 */ 924 update_wd =0; 925goto update_index; 926} 927 928 buf =read_object_file(oid, &type, &size); 929if(!buf) 930returnerr(o,_("cannot read object%s'%s'"),oid_to_hex(oid), path); 931if(type != OBJ_BLOB) { 932 ret =err(o,_("blob expected for%s'%s'"),oid_to_hex(oid), path); 933goto free_buf; 934} 935if(S_ISREG(mode)) { 936struct strbuf strbuf = STRBUF_INIT; 937if(convert_to_working_tree(path, buf, size, &strbuf)) { 938free(buf); 939 size = strbuf.len; 940 buf =strbuf_detach(&strbuf, NULL); 941} 942} 943 944if(make_room_for_path(o, path) <0) { 945 update_wd =0; 946goto free_buf; 947} 948if(S_ISREG(mode) || (!has_symlinks &&S_ISLNK(mode))) { 949int fd; 950if(mode &0100) 951 mode =0777; 952else 953 mode =0666; 954 fd =open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 955if(fd <0) { 956 ret =err(o,_("failed to open '%s':%s"), 957 path,strerror(errno)); 958goto free_buf; 959} 960write_in_full(fd, buf, size); 961close(fd); 962}else if(S_ISLNK(mode)) { 963char*lnk =xmemdupz(buf, size); 964safe_create_leading_directories_const(path); 965unlink(path); 966if(symlink(lnk, path)) 967 ret =err(o,_("failed to symlink '%s':%s"), 968 path,strerror(errno)); 969free(lnk); 970}else 971 ret =err(o, 972_("do not know what to do with%06o%s'%s'"), 973 mode,oid_to_hex(oid), path); 974 free_buf: 975free(buf); 976} 977 update_index: 978if(!ret && update_cache) 979if(add_cacheinfo(o, mode, oid, path,0, update_wd, 980 ADD_CACHE_OK_TO_ADD)) 981return-1; 982return ret; 983} 984 985static intupdate_file(struct merge_options *o, 986int clean, 987const struct object_id *oid, 988unsigned mode, 989const char*path) 990{ 991returnupdate_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth); 992} 993 994/* Low level file merging, update and removal */ 995 996struct merge_file_info { 997struct object_id oid; 998unsigned mode; 999unsigned clean:1,1000 merge:1;1001};10021003static intmerge_3way(struct merge_options *o,1004 mmbuffer_t *result_buf,1005const struct diff_filespec *one,1006const struct diff_filespec *a,1007const struct diff_filespec *b,1008const char*branch1,1009const char*branch2)1010{1011 mmfile_t orig, src1, src2;1012struct ll_merge_options ll_opts = {0};1013char*base_name, *name1, *name2;1014int merge_status;10151016 ll_opts.renormalize = o->renormalize;1017 ll_opts.xdl_opts = o->xdl_opts;10181019if(o->call_depth) {1020 ll_opts.virtual_ancestor =1;1021 ll_opts.variant =0;1022}else{1023switch(o->recursive_variant) {1024case MERGE_RECURSIVE_OURS:1025 ll_opts.variant = XDL_MERGE_FAVOR_OURS;1026break;1027case MERGE_RECURSIVE_THEIRS:1028 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;1029break;1030default:1031 ll_opts.variant =0;1032break;1033}1034}10351036if(strcmp(a->path, b->path) ||1037(o->ancestor != NULL &&strcmp(a->path, one->path) !=0)) {1038 base_name = o->ancestor == NULL ? NULL :1039mkpathdup("%s:%s", o->ancestor, one->path);1040 name1 =mkpathdup("%s:%s", branch1, a->path);1041 name2 =mkpathdup("%s:%s", branch2, b->path);1042}else{1043 base_name = o->ancestor == NULL ? NULL :1044mkpathdup("%s", o->ancestor);1045 name1 =mkpathdup("%s", branch1);1046 name2 =mkpathdup("%s", branch2);1047}10481049read_mmblob(&orig, &one->oid);1050read_mmblob(&src1, &a->oid);1051read_mmblob(&src2, &b->oid);10521053 merge_status =ll_merge(result_buf, a->path, &orig, base_name,1054&src1, name1, &src2, name2, &ll_opts);10551056free(base_name);1057free(name1);1058free(name2);1059free(orig.ptr);1060free(src1.ptr);1061free(src2.ptr);1062return merge_status;1063}10641065static intmerge_file_1(struct merge_options *o,1066const struct diff_filespec *one,1067const struct diff_filespec *a,1068const struct diff_filespec *b,1069const char*filename,1070const char*branch1,1071const char*branch2,1072struct merge_file_info *result)1073{1074 result->merge =0;1075 result->clean =1;10761077if((S_IFMT & a->mode) != (S_IFMT & b->mode)) {1078 result->clean =0;1079if(S_ISREG(a->mode)) {1080 result->mode = a->mode;1081oidcpy(&result->oid, &a->oid);1082}else{1083 result->mode = b->mode;1084oidcpy(&result->oid, &b->oid);1085}1086}else{1087if(!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))1088 result->merge =1;10891090/*1091 * Merge modes1092 */1093if(a->mode == b->mode || a->mode == one->mode)1094 result->mode = b->mode;1095else{1096 result->mode = a->mode;1097if(b->mode != one->mode) {1098 result->clean =0;1099 result->merge =1;1100}1101}11021103if(oid_eq(&a->oid, &b->oid) ||oid_eq(&a->oid, &one->oid))1104oidcpy(&result->oid, &b->oid);1105else if(oid_eq(&b->oid, &one->oid))1106oidcpy(&result->oid, &a->oid);1107else if(S_ISREG(a->mode)) {1108 mmbuffer_t result_buf;1109int ret =0, merge_status;11101111 merge_status =merge_3way(o, &result_buf, one, a, b,1112 branch1, branch2);11131114if((merge_status <0) || !result_buf.ptr)1115 ret =err(o,_("Failed to execute internal merge"));11161117if(!ret &&1118write_object_file(result_buf.ptr, result_buf.size,1119 blob_type, &result->oid))1120 ret =err(o,_("Unable to add%sto database"),1121 a->path);11221123free(result_buf.ptr);1124if(ret)1125return ret;1126 result->clean = (merge_status ==0);1127}else if(S_ISGITLINK(a->mode)) {1128 result->clean =merge_submodule(&result->oid,1129 one->path,1130&one->oid,1131&a->oid,1132&b->oid,1133!o->call_depth);1134}else if(S_ISLNK(a->mode)) {1135switch(o->recursive_variant) {1136case MERGE_RECURSIVE_NORMAL:1137oidcpy(&result->oid, &a->oid);1138if(!oid_eq(&a->oid, &b->oid))1139 result->clean =0;1140break;1141case MERGE_RECURSIVE_OURS:1142oidcpy(&result->oid, &a->oid);1143break;1144case MERGE_RECURSIVE_THEIRS:1145oidcpy(&result->oid, &b->oid);1146break;1147}1148}else1149die("BUG: unsupported object type in the tree");1150}11511152if(result->merge)1153output(o,2,_("Auto-merging%s"), filename);11541155return0;1156}11571158static intmerge_file_special_markers(struct merge_options *o,1159const struct diff_filespec *one,1160const struct diff_filespec *a,1161const struct diff_filespec *b,1162const char*target_filename,1163const char*branch1,1164const char*filename1,1165const char*branch2,1166const char*filename2,1167struct merge_file_info *mfi)1168{1169char*side1 = NULL;1170char*side2 = NULL;1171int ret;11721173if(filename1)1174 side1 =xstrfmt("%s:%s", branch1, filename1);1175if(filename2)1176 side2 =xstrfmt("%s:%s", branch2, filename2);11771178 ret =merge_file_1(o, one, a, b, target_filename,1179 side1 ? side1 : branch1,1180 side2 ? side2 : branch2, mfi);11811182free(side1);1183free(side2);1184return ret;1185}11861187static intmerge_file_one(struct merge_options *o,1188const char*path,1189const struct object_id *o_oid,int o_mode,1190const struct object_id *a_oid,int a_mode,1191const struct object_id *b_oid,int b_mode,1192const char*branch1,1193const char*branch2,1194struct merge_file_info *mfi)1195{1196struct diff_filespec one, a, b;11971198 one.path = a.path = b.path = (char*)path;1199oidcpy(&one.oid, o_oid);1200 one.mode = o_mode;1201oidcpy(&a.oid, a_oid);1202 a.mode = a_mode;1203oidcpy(&b.oid, b_oid);1204 b.mode = b_mode;1205returnmerge_file_1(o, &one, &a, &b, path, branch1, branch2, mfi);1206}12071208static intconflict_rename_dir(struct merge_options *o,1209struct diff_filepair *pair,1210const char*rename_branch,1211const char*other_branch)1212{1213const struct diff_filespec *dest = pair->two;12141215if(!o->call_depth &&would_lose_untracked(dest->path)) {1216char*alt_path =unique_path(o, dest->path, rename_branch);12171218output(o,1,_("Error: Refusing to lose untracked file at%s; "1219"writing to%sinstead."),1220 dest->path, alt_path);1221/*1222 * Write the file in worktree at alt_path, but not in the1223 * index. Instead, write to dest->path for the index but1224 * only at the higher appropriate stage.1225 */1226if(update_file(o,0, &dest->oid, dest->mode, alt_path))1227return-1;1228free(alt_path);1229returnupdate_stages(o, dest->path, NULL,1230 rename_branch == o->branch1 ? dest : NULL,1231 rename_branch == o->branch1 ? NULL : dest);1232}12331234/* Update dest->path both in index and in worktree */1235if(update_file(o,1, &dest->oid, dest->mode, dest->path))1236return-1;1237return0;1238}12391240static inthandle_change_delete(struct merge_options *o,1241const char*path,const char*old_path,1242const struct object_id *o_oid,int o_mode,1243const struct object_id *changed_oid,1244int changed_mode,1245const char*change_branch,1246const char*delete_branch,1247const char*change,const char*change_past)1248{1249char*alt_path = NULL;1250const char*update_path = path;1251int ret =0;12521253if(dir_in_way(path, !o->call_depth,0) ||1254(!o->call_depth &&would_lose_untracked(path))) {1255 update_path = alt_path =unique_path(o, path, change_branch);1256}12571258if(o->call_depth) {1259/*1260 * We cannot arbitrarily accept either a_sha or b_sha as1261 * correct; since there is no true "middle point" between1262 * them, simply reuse the base version for virtual merge base.1263 */1264 ret =remove_file_from_cache(path);1265if(!ret)1266 ret =update_file(o,0, o_oid, o_mode, update_path);1267}else{1268if(!alt_path) {1269if(!old_path) {1270output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1271"and%sin%s. Version%sof%sleft in tree."),1272 change, path, delete_branch, change_past,1273 change_branch, change_branch, path);1274}else{1275output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1276"and%sto%sin%s. Version%sof%sleft in tree."),1277 change, old_path, delete_branch, change_past, path,1278 change_branch, change_branch, path);1279}1280}else{1281if(!old_path) {1282output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1283"and%sin%s. Version%sof%sleft in tree at%s."),1284 change, path, delete_branch, change_past,1285 change_branch, change_branch, path, alt_path);1286}else{1287output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1288"and%sto%sin%s. Version%sof%sleft in tree at%s."),1289 change, old_path, delete_branch, change_past, path,1290 change_branch, change_branch, path, alt_path);1291}1292}1293/*1294 * No need to call update_file() on path when change_branch ==1295 * o->branch1 && !alt_path, since that would needlessly touch1296 * path. We could call update_file_flags() with update_cache=01297 * and update_wd=0, but that's a no-op.1298 */1299if(change_branch != o->branch1 || alt_path)1300 ret =update_file(o,0, changed_oid, changed_mode, update_path);1301}1302free(alt_path);13031304return ret;1305}13061307static intconflict_rename_delete(struct merge_options *o,1308struct diff_filepair *pair,1309const char*rename_branch,1310const char*delete_branch)1311{1312const struct diff_filespec *orig = pair->one;1313const struct diff_filespec *dest = pair->two;13141315if(handle_change_delete(o,1316 o->call_depth ? orig->path : dest->path,1317 o->call_depth ? NULL : orig->path,1318&orig->oid, orig->mode,1319&dest->oid, dest->mode,1320 rename_branch, delete_branch,1321_("rename"),_("renamed")))1322return-1;13231324if(o->call_depth)1325returnremove_file_from_cache(dest->path);1326else1327returnupdate_stages(o, dest->path, NULL,1328 rename_branch == o->branch1 ? dest : NULL,1329 rename_branch == o->branch1 ? NULL : dest);1330}13311332static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,1333struct stage_data *entry,1334int stage)1335{1336struct object_id *oid = &entry->stages[stage].oid;1337unsigned mode = entry->stages[stage].mode;1338if(mode ==0||is_null_oid(oid))1339return NULL;1340oidcpy(&target->oid, oid);1341 target->mode = mode;1342return target;1343}13441345static inthandle_file(struct merge_options *o,1346struct diff_filespec *rename,1347int stage,1348struct rename_conflict_info *ci)1349{1350char*dst_name = rename->path;1351struct stage_data *dst_entry;1352const char*cur_branch, *other_branch;1353struct diff_filespec other;1354struct diff_filespec *add;1355int ret;13561357if(stage ==2) {1358 dst_entry = ci->dst_entry1;1359 cur_branch = ci->branch1;1360 other_branch = ci->branch2;1361}else{1362 dst_entry = ci->dst_entry2;1363 cur_branch = ci->branch2;1364 other_branch = ci->branch1;1365}13661367 add =filespec_from_entry(&other, dst_entry, stage ^1);1368if(add) {1369int ren_src_was_dirty =was_dirty(o, rename->path);1370char*add_name =unique_path(o, rename->path, other_branch);1371if(update_file(o,0, &add->oid, add->mode, add_name))1372return-1;13731374if(ren_src_was_dirty) {1375output(o,1,_("Refusing to lose dirty file at%s"),1376 rename->path);1377}1378/*1379 * Because the double negatives somehow keep confusing me...1380 * 1) update_wd iff !ren_src_was_dirty.1381 * 2) no_wd iff !update_wd1382 * 3) so, no_wd == !!ren_src_was_dirty == ren_src_was_dirty1383 */1384remove_file(o,0, rename->path, ren_src_was_dirty);1385 dst_name =unique_path(o, rename->path, cur_branch);1386}else{1387if(dir_in_way(rename->path, !o->call_depth,0)) {1388 dst_name =unique_path(o, rename->path, cur_branch);1389output(o,1,_("%sis a directory in%sadding as%sinstead"),1390 rename->path, other_branch, dst_name);1391}else if(!o->call_depth &&1392would_lose_untracked(rename->path)) {1393 dst_name =unique_path(o, rename->path, cur_branch);1394output(o,1,_("Refusing to lose untracked file at%s; "1395"adding as%sinstead"),1396 rename->path, dst_name);1397}1398}1399if((ret =update_file(o,0, &rename->oid, rename->mode, dst_name)))1400;/* fall through, do allow dst_name to be released */1401else if(stage ==2)1402 ret =update_stages(o, rename->path, NULL, rename, add);1403else1404 ret =update_stages(o, rename->path, NULL, add, rename);14051406if(dst_name != rename->path)1407free(dst_name);14081409return ret;1410}14111412static intconflict_rename_rename_1to2(struct merge_options *o,1413struct rename_conflict_info *ci)1414{1415/* One file was renamed in both branches, but to different names. */1416struct diff_filespec *one = ci->pair1->one;1417struct diff_filespec *a = ci->pair1->two;1418struct diff_filespec *b = ci->pair2->two;14191420output(o,1,_("CONFLICT (rename/rename): "1421"Rename\"%s\"->\"%s\"in branch\"%s\""1422"rename\"%s\"->\"%s\"in\"%s\"%s"),1423 one->path, a->path, ci->branch1,1424 one->path, b->path, ci->branch2,1425 o->call_depth ?_(" (left unresolved)") :"");1426if(o->call_depth) {1427struct merge_file_info mfi;1428struct diff_filespec other;1429struct diff_filespec *add;1430if(merge_file_one(o, one->path,1431&one->oid, one->mode,1432&a->oid, a->mode,1433&b->oid, b->mode,1434 ci->branch1, ci->branch2, &mfi))1435return-1;14361437/*1438 * FIXME: For rename/add-source conflicts (if we could detect1439 * such), this is wrong. We should instead find a unique1440 * pathname and then either rename the add-source file to that1441 * unique path, or use that unique path instead of src here.1442 */1443if(update_file(o,0, &mfi.oid, mfi.mode, one->path))1444return-1;14451446/*1447 * Above, we put the merged content at the merge-base's1448 * path. Now we usually need to delete both a->path and1449 * b->path. However, the rename on each side of the merge1450 * could also be involved in a rename/add conflict. In1451 * such cases, we should keep the added file around,1452 * resolving the conflict at that path in its favor.1453 */1454 add =filespec_from_entry(&other, ci->dst_entry1,2^1);1455if(add) {1456if(update_file(o,0, &add->oid, add->mode, a->path))1457return-1;1458}1459else1460remove_file_from_cache(a->path);1461 add =filespec_from_entry(&other, ci->dst_entry2,3^1);1462if(add) {1463if(update_file(o,0, &add->oid, add->mode, b->path))1464return-1;1465}1466else1467remove_file_from_cache(b->path);1468}else if(handle_file(o, a,2, ci) ||handle_file(o, b,3, ci))1469return-1;14701471return0;1472}14731474static intconflict_rename_rename_2to1(struct merge_options *o,1475struct rename_conflict_info *ci)1476{1477/* Two files, a & b, were renamed to the same thing, c. */1478struct diff_filespec *a = ci->pair1->one;1479struct diff_filespec *b = ci->pair2->one;1480struct diff_filespec *c1 = ci->pair1->two;1481struct diff_filespec *c2 = ci->pair2->two;1482char*path = c1->path;/* == c2->path */1483char*path_side_1_desc;1484char*path_side_2_desc;1485struct merge_file_info mfi_c1;1486struct merge_file_info mfi_c2;1487int ret;14881489output(o,1,_("CONFLICT (rename/rename): "1490"Rename%s->%sin%s. "1491"Rename%s->%sin%s"),1492 a->path, c1->path, ci->branch1,1493 b->path, c2->path, ci->branch2);14941495remove_file(o,1, a->path, o->call_depth ||would_lose_untracked(a->path));1496remove_file(o,1, b->path, o->call_depth ||would_lose_untracked(b->path));14971498 path_side_1_desc =xstrfmt("%s(was%s)", path, a->path);1499 path_side_2_desc =xstrfmt("%s(was%s)", path, b->path);1500if(merge_file_special_markers(o, a, c1, &ci->ren1_other,1501 path_side_1_desc,1502 o->branch1, c1->path,1503 o->branch2, ci->ren1_other.path, &mfi_c1) ||1504merge_file_special_markers(o, b, &ci->ren2_other, c2,1505 path_side_2_desc,1506 o->branch1, ci->ren2_other.path,1507 o->branch2, c2->path, &mfi_c2))1508return-1;1509free(path_side_1_desc);1510free(path_side_2_desc);15111512if(o->call_depth) {1513/*1514 * If mfi_c1.clean && mfi_c2.clean, then it might make1515 * sense to do a two-way merge of those results. But, I1516 * think in all cases, it makes sense to have the virtual1517 * merge base just undo the renames; they can be detected1518 * again later for the non-recursive merge.1519 */1520remove_file(o,0, path,0);1521 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, a->path);1522if(!ret)1523 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1524 b->path);1525}else{1526char*new_path1 =unique_path(o, path, ci->branch1);1527char*new_path2 =unique_path(o, path, ci->branch2);1528output(o,1,_("Renaming%sto%sand%sto%sinstead"),1529 a->path, new_path1, b->path, new_path2);1530if(was_dirty(o, path))1531output(o,1,_("Refusing to lose dirty file at%s"),1532 path);1533else if(would_lose_untracked(path))1534/*1535 * Only way we get here is if both renames were from1536 * a directory rename AND user had an untracked file1537 * at the location where both files end up after the1538 * two directory renames. See testcase 10d of t6043.1539 */1540output(o,1,_("Refusing to lose untracked file at "1541"%s, even though it's in the way."),1542 path);1543else1544remove_file(o,0, path,0);1545 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, new_path1);1546if(!ret)1547 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1548 new_path2);1549/*1550 * unpack_trees() actually populates the index for us for1551 * "normal" rename/rename(2to1) situtations so that the1552 * correct entries are at the higher stages, which would1553 * make the call below to update_stages_for_stage_data1554 * unnecessary. However, if either of the renames came1555 * from a directory rename, then unpack_trees() will not1556 * have gotten the right data loaded into the index, so we1557 * need to do so now. (While it'd be tempting to move this1558 * call to update_stages_for_stage_data() to1559 * apply_directory_rename_modifications(), that would break1560 * our intermediate calls to would_lose_untracked() since1561 * those rely on the current in-memory index. See also the1562 * big "NOTE" in update_stages()).1563 */1564if(update_stages_for_stage_data(o, path, ci->dst_entry1))1565 ret = -1;15661567free(new_path2);1568free(new_path1);1569}15701571return ret;1572}15731574/*1575 * Get the diff_filepairs changed between o_tree and tree.1576 */1577static struct diff_queue_struct *get_diffpairs(struct merge_options *o,1578struct tree *o_tree,1579struct tree *tree)1580{1581struct diff_queue_struct *ret;1582struct diff_options opts;15831584diff_setup(&opts);1585 opts.flags.recursive =1;1586 opts.flags.rename_empty =0;1587 opts.detect_rename = DIFF_DETECT_RENAME;1588 opts.rename_limit = o->merge_rename_limit >=0? o->merge_rename_limit :1589 o->diff_rename_limit >=0? o->diff_rename_limit :15901000;1591 opts.rename_score = o->rename_score;1592 opts.show_rename_progress = o->show_rename_progress;1593 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1594diff_setup_done(&opts);1595diff_tree_oid(&o_tree->object.oid, &tree->object.oid,"", &opts);1596diffcore_std(&opts);1597if(opts.needed_rename_limit > o->needed_rename_limit)1598 o->needed_rename_limit = opts.needed_rename_limit;15991600 ret =xmalloc(sizeof(*ret));1601*ret = diff_queued_diff;16021603 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1604 diff_queued_diff.nr =0;1605 diff_queued_diff.queue = NULL;1606diff_flush(&opts);1607return ret;1608}16091610static inttree_has_path(struct tree *tree,const char*path)1611{1612struct object_id hashy;1613unsigned int mode_o;16141615return!get_tree_entry(&tree->object.oid, path,1616&hashy, &mode_o);1617}16181619/*1620 * Return a new string that replaces the beginning portion (which matches1621 * entry->dir), with entry->new_dir. In perl-speak:1622 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1623 * NOTE:1624 * Caller must ensure that old_path starts with entry->dir + '/'.1625 */1626static char*apply_dir_rename(struct dir_rename_entry *entry,1627const char*old_path)1628{1629struct strbuf new_path = STRBUF_INIT;1630int oldlen, newlen;16311632if(entry->non_unique_new_dir)1633return NULL;16341635 oldlen =strlen(entry->dir);1636 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) +1;1637strbuf_grow(&new_path, newlen);1638strbuf_addbuf(&new_path, &entry->new_dir);1639strbuf_addstr(&new_path, &old_path[oldlen]);16401641returnstrbuf_detach(&new_path, NULL);1642}16431644static voidget_renamed_dir_portion(const char*old_path,const char*new_path,1645char**old_dir,char**new_dir)1646{1647char*end_of_old, *end_of_new;1648int old_len, new_len;16491650*old_dir = NULL;1651*new_dir = NULL;16521653/*1654 * For1655 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1656 * the "e/foo.c" part is the same, we just want to know that1657 * "a/b/c/d" was renamed to "a/b/some/thing/else"1658 * so, for this example, this function returns "a/b/c/d" in1659 * *old_dir and "a/b/some/thing/else" in *new_dir.1660 *1661 * Also, if the basename of the file changed, we don't care. We1662 * want to know which portion of the directory, if any, changed.1663 */1664 end_of_old =strrchr(old_path,'/');1665 end_of_new =strrchr(new_path,'/');16661667if(end_of_old == NULL || end_of_new == NULL)1668return;1669while(*--end_of_new == *--end_of_old &&1670 end_of_old != old_path &&1671 end_of_new != new_path)1672;/* Do nothing; all in the while loop */1673/*1674 * We've found the first non-matching character in the directory1675 * paths. That means the current directory we were comparing1676 * represents the rename. Move end_of_old and end_of_new back1677 * to the full directory name.1678 */1679if(*end_of_old =='/')1680 end_of_old++;1681if(*end_of_old !='/')1682 end_of_new++;1683 end_of_old =strchr(end_of_old,'/');1684 end_of_new =strchr(end_of_new,'/');16851686/*1687 * It may have been the case that old_path and new_path were the same1688 * directory all along. Don't claim a rename if they're the same.1689 */1690 old_len = end_of_old - old_path;1691 new_len = end_of_new - new_path;16921693if(old_len != new_len ||strncmp(old_path, new_path, old_len)) {1694*old_dir =xstrndup(old_path, old_len);1695*new_dir =xstrndup(new_path, new_len);1696}1697}16981699static voidremove_hashmap_entries(struct hashmap *dir_renames,1700struct string_list *items_to_remove)1701{1702int i;1703struct dir_rename_entry *entry;17041705for(i =0; i < items_to_remove->nr; i++) {1706 entry = items_to_remove->items[i].util;1707hashmap_remove(dir_renames, entry, NULL);1708}1709string_list_clear(items_to_remove,0);1710}17111712/*1713 * See if there is a directory rename for path, and if there are any file1714 * level conflicts for the renamed location. If there is a rename and1715 * there are no conflicts, return the new name. Otherwise, return NULL.1716 */1717static char*handle_path_level_conflicts(struct merge_options *o,1718const char*path,1719struct dir_rename_entry *entry,1720struct hashmap *collisions,1721struct tree *tree)1722{1723char*new_path = NULL;1724struct collision_entry *collision_ent;1725int clean =1;1726struct strbuf collision_paths = STRBUF_INIT;17271728/*1729 * entry has the mapping of old directory name to new directory name1730 * that we want to apply to path.1731 */1732 new_path =apply_dir_rename(entry, path);17331734if(!new_path) {1735/* This should only happen when entry->non_unique_new_dir set */1736if(!entry->non_unique_new_dir)1737BUG("entry->non_unqiue_dir not set and !new_path");1738output(o,1,_("CONFLICT (directory rename split): "1739"Unclear where to place%sbecause directory "1740"%swas renamed to multiple other directories, "1741"with no destination getting a majority of the "1742"files."),1743 path, entry->dir);1744 clean =0;1745return NULL;1746}17471748/*1749 * The caller needs to have ensured that it has pre-populated1750 * collisions with all paths that map to new_path. Do a quick check1751 * to ensure that's the case.1752 */1753 collision_ent =collision_find_entry(collisions, new_path);1754if(collision_ent == NULL)1755BUG("collision_ent is NULL");17561757/*1758 * Check for one-sided add/add/.../add conflicts, i.e.1759 * where implicit renames from the other side doing1760 * directory rename(s) can affect this side of history1761 * to put multiple paths into the same location. Warn1762 * and bail on directory renames for such paths.1763 */1764if(collision_ent->reported_already) {1765 clean =0;1766}else if(tree_has_path(tree, new_path)) {1767 collision_ent->reported_already =1;1768strbuf_add_separated_string_list(&collision_paths,", ",1769&collision_ent->source_files);1770output(o,1,_("CONFLICT (implicit dir rename): Existing "1771"file/dir at%sin the way of implicit "1772"directory rename(s) putting the following "1773"path(s) there:%s."),1774 new_path, collision_paths.buf);1775 clean =0;1776}else if(collision_ent->source_files.nr >1) {1777 collision_ent->reported_already =1;1778strbuf_add_separated_string_list(&collision_paths,", ",1779&collision_ent->source_files);1780output(o,1,_("CONFLICT (implicit dir rename): Cannot map "1781"more than one path to%s; implicit directory "1782"renames tried to put these paths there:%s"),1783 new_path, collision_paths.buf);1784 clean =0;1785}17861787/* Free memory we no longer need */1788strbuf_release(&collision_paths);1789if(!clean && new_path) {1790free(new_path);1791return NULL;1792}17931794return new_path;1795}17961797/*1798 * There are a couple things we want to do at the directory level:1799 * 1. Check for both sides renaming to the same thing, in order to avoid1800 * implicit renaming of files that should be left in place. (See1801 * testcase 6b in t6043 for details.)1802 * 2. Prune directory renames if there are still files left in the1803 * the original directory. These represent a partial directory rename,1804 * i.e. a rename where only some of the files within the directory1805 * were renamed elsewhere. (Technically, this could be done earlier1806 * in get_directory_renames(), except that would prevent us from1807 * doing the previous check and thus failing testcase 6b.)1808 * 3. Check for rename/rename(1to2) conflicts (at the directory level).1809 * In the future, we could potentially record this info as well and1810 * omit reporting rename/rename(1to2) conflicts for each path within1811 * the affected directories, thus cleaning up the merge output.1812 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the1813 * directory level, because merging directories is fine. If it1814 * causes conflicts for files within those merged directories, then1815 * that should be detected at the individual path level.1816 */1817static voidhandle_directory_level_conflicts(struct merge_options *o,1818struct hashmap *dir_re_head,1819struct tree *head,1820struct hashmap *dir_re_merge,1821struct tree *merge)1822{1823struct hashmap_iter iter;1824struct dir_rename_entry *head_ent;1825struct dir_rename_entry *merge_ent;18261827struct string_list remove_from_head = STRING_LIST_INIT_NODUP;1828struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;18291830hashmap_iter_init(dir_re_head, &iter);1831while((head_ent =hashmap_iter_next(&iter))) {1832 merge_ent =dir_rename_find_entry(dir_re_merge, head_ent->dir);1833if(merge_ent &&1834!head_ent->non_unique_new_dir &&1835!merge_ent->non_unique_new_dir &&1836!strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {1837/* 1. Renamed identically; remove it from both sides */1838string_list_append(&remove_from_head,1839 head_ent->dir)->util = head_ent;1840strbuf_release(&head_ent->new_dir);1841string_list_append(&remove_from_merge,1842 merge_ent->dir)->util = merge_ent;1843strbuf_release(&merge_ent->new_dir);1844}else if(tree_has_path(head, head_ent->dir)) {1845/* 2. This wasn't a directory rename after all */1846string_list_append(&remove_from_head,1847 head_ent->dir)->util = head_ent;1848strbuf_release(&head_ent->new_dir);1849}1850}18511852remove_hashmap_entries(dir_re_head, &remove_from_head);1853remove_hashmap_entries(dir_re_merge, &remove_from_merge);18541855hashmap_iter_init(dir_re_merge, &iter);1856while((merge_ent =hashmap_iter_next(&iter))) {1857 head_ent =dir_rename_find_entry(dir_re_head, merge_ent->dir);1858if(tree_has_path(merge, merge_ent->dir)) {1859/* 2. This wasn't a directory rename after all */1860string_list_append(&remove_from_merge,1861 merge_ent->dir)->util = merge_ent;1862}else if(head_ent &&1863!head_ent->non_unique_new_dir &&1864!merge_ent->non_unique_new_dir) {1865/* 3. rename/rename(1to2) */1866/*1867 * We can assume it's not rename/rename(1to1) because1868 * that was case (1), already checked above. So we1869 * know that head_ent->new_dir and merge_ent->new_dir1870 * are different strings.1871 */1872output(o,1,_("CONFLICT (rename/rename): "1873"Rename directory%s->%sin%s. "1874"Rename directory%s->%sin%s"),1875 head_ent->dir, head_ent->new_dir.buf, o->branch1,1876 head_ent->dir, merge_ent->new_dir.buf, o->branch2);1877string_list_append(&remove_from_head,1878 head_ent->dir)->util = head_ent;1879strbuf_release(&head_ent->new_dir);1880string_list_append(&remove_from_merge,1881 merge_ent->dir)->util = merge_ent;1882strbuf_release(&merge_ent->new_dir);1883}1884}18851886remove_hashmap_entries(dir_re_head, &remove_from_head);1887remove_hashmap_entries(dir_re_merge, &remove_from_merge);1888}18891890static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,1891struct tree *tree)1892{1893struct hashmap *dir_renames;1894struct hashmap_iter iter;1895struct dir_rename_entry *entry;1896int i;18971898/*1899 * Typically, we think of a directory rename as all files from a1900 * certain directory being moved to a target directory. However,1901 * what if someone first moved two files from the original1902 * directory in one commit, and then renamed the directory1903 * somewhere else in a later commit? At merge time, we just know1904 * that files from the original directory went to two different1905 * places, and that the bulk of them ended up in the same place.1906 * We want each directory rename to represent where the bulk of the1907 * files from that directory end up; this function exists to find1908 * where the bulk of the files went.1909 *1910 * The first loop below simply iterates through the list of file1911 * renames, finding out how often each directory rename pair1912 * possibility occurs.1913 */1914 dir_renames =xmalloc(sizeof(*dir_renames));1915dir_rename_init(dir_renames);1916for(i =0; i < pairs->nr; ++i) {1917struct string_list_item *item;1918int*count;1919struct diff_filepair *pair = pairs->queue[i];1920char*old_dir, *new_dir;19211922/* File not part of directory rename if it wasn't renamed */1923if(pair->status !='R')1924continue;19251926get_renamed_dir_portion(pair->one->path, pair->two->path,1927&old_dir, &new_dir);1928if(!old_dir)1929/* Directory didn't change at all; ignore this one. */1930continue;19311932 entry =dir_rename_find_entry(dir_renames, old_dir);1933if(!entry) {1934 entry =xmalloc(sizeof(*entry));1935dir_rename_entry_init(entry, old_dir);1936hashmap_put(dir_renames, entry);1937}else{1938free(old_dir);1939}1940 item =string_list_lookup(&entry->possible_new_dirs, new_dir);1941if(!item) {1942 item =string_list_insert(&entry->possible_new_dirs,1943 new_dir);1944 item->util =xcalloc(1,sizeof(int));1945}else{1946free(new_dir);1947}1948 count = item->util;1949*count +=1;1950}19511952/*1953 * For each directory with files moved out of it, we find out which1954 * target directory received the most files so we can declare it to1955 * be the "winning" target location for the directory rename. This1956 * winner gets recorded in new_dir. If there is no winner1957 * (multiple target directories received the same number of files),1958 * we set non_unique_new_dir. Once we've determined the winner (or1959 * that there is no winner), we no longer need possible_new_dirs.1960 */1961hashmap_iter_init(dir_renames, &iter);1962while((entry =hashmap_iter_next(&iter))) {1963int max =0;1964int bad_max =0;1965char*best = NULL;19661967for(i =0; i < entry->possible_new_dirs.nr; i++) {1968int*count = entry->possible_new_dirs.items[i].util;19691970if(*count == max)1971 bad_max = max;1972else if(*count > max) {1973 max = *count;1974 best = entry->possible_new_dirs.items[i].string;1975}1976}1977if(bad_max == max)1978 entry->non_unique_new_dir =1;1979else{1980assert(entry->new_dir.len ==0);1981strbuf_addstr(&entry->new_dir, best);1982}1983/*1984 * The relevant directory sub-portion of the original full1985 * filepaths were xstrndup'ed before inserting into1986 * possible_new_dirs, and instead of manually iterating the1987 * list and free'ing each, just lie and tell1988 * possible_new_dirs that it did the strdup'ing so that it1989 * will free them for us.1990 */1991 entry->possible_new_dirs.strdup_strings =1;1992string_list_clear(&entry->possible_new_dirs,1);1993}19941995return dir_renames;1996}19971998static struct dir_rename_entry *check_dir_renamed(const char*path,1999struct hashmap *dir_renames)2000{2001char temp[PATH_MAX];2002char*end;2003struct dir_rename_entry *entry;20042005strcpy(temp, path);2006while((end =strrchr(temp,'/'))) {2007*end ='\0';2008 entry =dir_rename_find_entry(dir_renames, temp);2009if(entry)2010return entry;2011}2012return NULL;2013}20142015static voidcompute_collisions(struct hashmap *collisions,2016struct hashmap *dir_renames,2017struct diff_queue_struct *pairs)2018{2019int i;20202021/*2022 * Multiple files can be mapped to the same path due to directory2023 * renames done by the other side of history. Since that other2024 * side of history could have merged multiple directories into one,2025 * if our side of history added the same file basename to each of2026 * those directories, then all N of them would get implicitly2027 * renamed by the directory rename detection into the same path,2028 * and we'd get an add/add/.../add conflict, and all those adds2029 * from *this* side of history. This is not representable in the2030 * index, and users aren't going to easily be able to make sense of2031 * it. So we need to provide a good warning about what's2032 * happening, and fall back to no-directory-rename detection2033 * behavior for those paths.2034 *2035 * See testcases 9e and all of section 5 from t6043 for examples.2036 */2037collision_init(collisions);20382039for(i =0; i < pairs->nr; ++i) {2040struct dir_rename_entry *dir_rename_ent;2041struct collision_entry *collision_ent;2042char*new_path;2043struct diff_filepair *pair = pairs->queue[i];20442045if(pair->status !='A'&& pair->status !='R')2046continue;2047 dir_rename_ent =check_dir_renamed(pair->two->path,2048 dir_renames);2049if(!dir_rename_ent)2050continue;20512052 new_path =apply_dir_rename(dir_rename_ent, pair->two->path);2053if(!new_path)2054/*2055 * dir_rename_ent->non_unique_new_path is true, which2056 * means there is no directory rename for us to use,2057 * which means it won't cause us any additional2058 * collisions.2059 */2060continue;2061 collision_ent =collision_find_entry(collisions, new_path);2062if(!collision_ent) {2063 collision_ent =xcalloc(1,2064sizeof(struct collision_entry));2065hashmap_entry_init(collision_ent,strhash(new_path));2066hashmap_put(collisions, collision_ent);2067 collision_ent->target_file = new_path;2068}else{2069free(new_path);2070}2071string_list_insert(&collision_ent->source_files,2072 pair->two->path);2073}2074}20752076static char*check_for_directory_rename(struct merge_options *o,2077const char*path,2078struct tree *tree,2079struct hashmap *dir_renames,2080struct hashmap *dir_rename_exclusions,2081struct hashmap *collisions,2082int*clean_merge)2083{2084char*new_path = NULL;2085struct dir_rename_entry *entry =check_dir_renamed(path, dir_renames);2086struct dir_rename_entry *oentry = NULL;20872088if(!entry)2089return new_path;20902091/*2092 * This next part is a little weird. We do not want to do an2093 * implicit rename into a directory we renamed on our side, because2094 * that will result in a spurious rename/rename(1to2) conflict. An2095 * example:2096 * Base commit: dumbdir/afile, otherdir/bfile2097 * Side 1: smrtdir/afile, otherdir/bfile2098 * Side 2: dumbdir/afile, dumbdir/bfile2099 * Here, while working on Side 1, we could notice that otherdir was2100 * renamed/merged to dumbdir, and change the diff_filepair for2101 * otherdir/bfile into a rename into dumbdir/bfile. However, Side2102 * 2 will notice the rename from dumbdir to smrtdir, and do the2103 * transitive rename to move it from dumbdir/bfile to2104 * smrtdir/bfile. That gives us bfile in dumbdir vs being in2105 * smrtdir, a rename/rename(1to2) conflict. We really just want2106 * the file to end up in smrtdir. And the way to achieve that is2107 * to not let Side1 do the rename to dumbdir, since we know that is2108 * the source of one of our directory renames.2109 *2110 * That's why oentry and dir_rename_exclusions is here.2111 *2112 * As it turns out, this also prevents N-way transient rename2113 * confusion; See testcases 9c and 9d of t6043.2114 */2115 oentry =dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);2116if(oentry) {2117output(o,1,_("WARNING: Avoiding applying%s->%srename "2118"to%s, because%sitself was renamed."),2119 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);2120}else{2121 new_path =handle_path_level_conflicts(o, path, entry,2122 collisions, tree);2123*clean_merge &= (new_path != NULL);2124}21252126return new_path;2127}21282129static voidapply_directory_rename_modifications(struct merge_options *o,2130struct diff_filepair *pair,2131char*new_path,2132struct rename *re,2133struct tree *tree,2134struct tree *o_tree,2135struct tree *a_tree,2136struct tree *b_tree,2137struct string_list *entries,2138int*clean)2139{2140struct string_list_item *item;2141int stage = (tree == a_tree ?2:3);2142int update_wd;21432144/*2145 * In all cases where we can do directory rename detection,2146 * unpack_trees() will have read pair->two->path into the2147 * index and the working copy. We need to remove it so that2148 * we can instead place it at new_path. It is guaranteed to2149 * not be untracked (unpack_trees() would have errored out2150 * saying the file would have been overwritten), but it might2151 * be dirty, though.2152 */2153 update_wd = !was_dirty(o, pair->two->path);2154if(!update_wd)2155output(o,1,_("Refusing to lose dirty file at%s"),2156 pair->two->path);2157remove_file(o,1, pair->two->path, !update_wd);21582159/* Find or create a new re->dst_entry */2160 item =string_list_lookup(entries, new_path);2161if(item) {2162/*2163 * Since we're renaming on this side of history, and it's2164 * due to a directory rename on the other side of history2165 * (which we only allow when the directory in question no2166 * longer exists on the other side of history), the2167 * original entry for re->dst_entry is no longer2168 * necessary...2169 */2170 re->dst_entry->processed =1;21712172/*2173 * ...because we'll be using this new one.2174 */2175 re->dst_entry = item->util;2176}else{2177/*2178 * re->dst_entry is for the before-dir-rename path, and we2179 * need it to hold information for the after-dir-rename2180 * path. Before creating a new entry, we need to mark the2181 * old one as unnecessary (...unless it is shared by2182 * src_entry, i.e. this didn't use to be a rename, in which2183 * case we can just allow the normal processing to happen2184 * for it).2185 */2186if(pair->status =='R')2187 re->dst_entry->processed =1;21882189 re->dst_entry =insert_stage_data(new_path,2190 o_tree, a_tree, b_tree,2191 entries);2192 item =string_list_insert(entries, new_path);2193 item->util = re->dst_entry;2194}21952196/*2197 * Update the stage_data with the information about the path we are2198 * moving into place. That slot will be empty and available for us2199 * to write to because of the collision checks in2200 * handle_path_level_conflicts(). In other words,2201 * re->dst_entry->stages[stage].oid will be the null_oid, so it's2202 * open for us to write to.2203 *2204 * It may be tempting to actually update the index at this point as2205 * well, using update_stages_for_stage_data(), but as per the big2206 * "NOTE" in update_stages(), doing so will modify the current2207 * in-memory index which will break calls to would_lose_untracked()2208 * that we need to make. Instead, we need to just make sure that2209 * the various conflict_rename_*() functions update the index2210 * explicitly rather than relying on unpack_trees() to have done it.2211 */2212get_tree_entry(&tree->object.oid,2213 pair->two->path,2214&re->dst_entry->stages[stage].oid,2215&re->dst_entry->stages[stage].mode);22162217/* Update pair status */2218if(pair->status =='A') {2219/*2220 * Recording rename information for this add makes it look2221 * like a rename/delete conflict. Make sure we can2222 * correctly handle this as an add that was moved to a new2223 * directory instead of reporting a rename/delete conflict.2224 */2225 re->add_turned_into_rename =1;2226}2227/*2228 * We don't actually look at pair->status again, but it seems2229 * pedagogically correct to adjust it.2230 */2231 pair->status ='R';22322233/*2234 * Finally, record the new location.2235 */2236 pair->two->path = new_path;2237}22382239/*2240 * Get information of all renames which occurred in 'pairs', making use of2241 * any implicit directory renames inferred from the other side of history.2242 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')2243 * to be able to associate the correct cache entries with the rename2244 * information; tree is always equal to either a_tree or b_tree.2245 */2246static struct string_list *get_renames(struct merge_options *o,2247struct diff_queue_struct *pairs,2248struct hashmap *dir_renames,2249struct hashmap *dir_rename_exclusions,2250struct tree *tree,2251struct tree *o_tree,2252struct tree *a_tree,2253struct tree *b_tree,2254struct string_list *entries,2255int*clean_merge)2256{2257int i;2258struct hashmap collisions;2259struct hashmap_iter iter;2260struct collision_entry *e;2261struct string_list *renames;22622263compute_collisions(&collisions, dir_renames, pairs);2264 renames =xcalloc(1,sizeof(struct string_list));22652266for(i =0; i < pairs->nr; ++i) {2267struct string_list_item *item;2268struct rename *re;2269struct diff_filepair *pair = pairs->queue[i];2270char*new_path;/* non-NULL only with directory renames */22712272if(pair->status !='A'&& pair->status !='R') {2273diff_free_filepair(pair);2274continue;2275}2276 new_path =check_for_directory_rename(o, pair->two->path, tree,2277 dir_renames,2278 dir_rename_exclusions,2279&collisions,2280 clean_merge);2281if(pair->status !='R'&& !new_path) {2282diff_free_filepair(pair);2283continue;2284}22852286 re =xmalloc(sizeof(*re));2287 re->processed =0;2288 re->add_turned_into_rename =0;2289 re->pair = pair;2290 item =string_list_lookup(entries, re->pair->one->path);2291if(!item)2292 re->src_entry =insert_stage_data(re->pair->one->path,2293 o_tree, a_tree, b_tree, entries);2294else2295 re->src_entry = item->util;22962297 item =string_list_lookup(entries, re->pair->two->path);2298if(!item)2299 re->dst_entry =insert_stage_data(re->pair->two->path,2300 o_tree, a_tree, b_tree, entries);2301else2302 re->dst_entry = item->util;2303 item =string_list_insert(renames, pair->one->path);2304 item->util = re;2305if(new_path)2306apply_directory_rename_modifications(o, pair, new_path,2307 re, tree, o_tree,2308 a_tree, b_tree,2309 entries,2310 clean_merge);2311}23122313hashmap_iter_init(&collisions, &iter);2314while((e =hashmap_iter_next(&iter))) {2315free(e->target_file);2316string_list_clear(&e->source_files,0);2317}2318hashmap_free(&collisions,1);2319return renames;2320}23212322static intprocess_renames(struct merge_options *o,2323struct string_list *a_renames,2324struct string_list *b_renames)2325{2326int clean_merge =1, i, j;2327struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2328struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2329const struct rename *sre;23302331for(i =0; i < a_renames->nr; i++) {2332 sre = a_renames->items[i].util;2333string_list_insert(&a_by_dst, sre->pair->two->path)->util2334= (void*)sre;2335}2336for(i =0; i < b_renames->nr; i++) {2337 sre = b_renames->items[i].util;2338string_list_insert(&b_by_dst, sre->pair->two->path)->util2339= (void*)sre;2340}23412342for(i =0, j =0; i < a_renames->nr || j < b_renames->nr;) {2343struct string_list *renames1, *renames2Dst;2344struct rename *ren1 = NULL, *ren2 = NULL;2345const char*branch1, *branch2;2346const char*ren1_src, *ren1_dst;2347struct string_list_item *lookup;23482349if(i >= a_renames->nr) {2350 ren2 = b_renames->items[j++].util;2351}else if(j >= b_renames->nr) {2352 ren1 = a_renames->items[i++].util;2353}else{2354int compare =strcmp(a_renames->items[i].string,2355 b_renames->items[j].string);2356if(compare <=0)2357 ren1 = a_renames->items[i++].util;2358if(compare >=0)2359 ren2 = b_renames->items[j++].util;2360}23612362/* TODO: refactor, so that 1/2 are not needed */2363if(ren1) {2364 renames1 = a_renames;2365 renames2Dst = &b_by_dst;2366 branch1 = o->branch1;2367 branch2 = o->branch2;2368}else{2369 renames1 = b_renames;2370 renames2Dst = &a_by_dst;2371 branch1 = o->branch2;2372 branch2 = o->branch1;2373SWAP(ren2, ren1);2374}23752376if(ren1->processed)2377continue;2378 ren1->processed =1;2379 ren1->dst_entry->processed =1;2380/* BUG: We should only mark src_entry as processed if we2381 * are not dealing with a rename + add-source case.2382 */2383 ren1->src_entry->processed =1;23842385 ren1_src = ren1->pair->one->path;2386 ren1_dst = ren1->pair->two->path;23872388if(ren2) {2389/* One file renamed on both sides */2390const char*ren2_src = ren2->pair->one->path;2391const char*ren2_dst = ren2->pair->two->path;2392enum rename_type rename_type;2393if(strcmp(ren1_src, ren2_src) !=0)2394die("BUG: ren1_src != ren2_src");2395 ren2->dst_entry->processed =1;2396 ren2->processed =1;2397if(strcmp(ren1_dst, ren2_dst) !=0) {2398 rename_type = RENAME_ONE_FILE_TO_TWO;2399 clean_merge =0;2400}else{2401 rename_type = RENAME_ONE_FILE_TO_ONE;2402/* BUG: We should only remove ren1_src in2403 * the base stage (think of rename +2404 * add-source cases).2405 */2406remove_file(o,1, ren1_src,1);2407update_entry(ren1->dst_entry,2408 ren1->pair->one,2409 ren1->pair->two,2410 ren2->pair->two);2411}2412setup_rename_conflict_info(rename_type,2413 ren1->pair,2414 ren2->pair,2415 branch1,2416 branch2,2417 ren1->dst_entry,2418 ren2->dst_entry,2419 o,2420 NULL,2421 NULL);2422}else if((lookup =string_list_lookup(renames2Dst, ren1_dst))) {2423/* Two different files renamed to the same thing */2424char*ren2_dst;2425 ren2 = lookup->util;2426 ren2_dst = ren2->pair->two->path;2427if(strcmp(ren1_dst, ren2_dst) !=0)2428die("BUG: ren1_dst != ren2_dst");24292430 clean_merge =0;2431 ren2->processed =1;2432/*2433 * BUG: We should only mark src_entry as processed2434 * if we are not dealing with a rename + add-source2435 * case.2436 */2437 ren2->src_entry->processed =1;24382439setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2440 ren1->pair,2441 ren2->pair,2442 branch1,2443 branch2,2444 ren1->dst_entry,2445 ren2->dst_entry,2446 o,2447 ren1->src_entry,2448 ren2->src_entry);24492450}else{2451/* Renamed in 1, maybe changed in 2 */2452/* we only use sha1 and mode of these */2453struct diff_filespec src_other, dst_other;2454int try_merge;24552456/*2457 * unpack_trees loads entries from common-commit2458 * into stage 1, from head-commit into stage 2, and2459 * from merge-commit into stage 3. We keep track2460 * of which side corresponds to the rename.2461 */2462int renamed_stage = a_renames == renames1 ?2:3;2463int other_stage = a_renames == renames1 ?3:2;24642465/* BUG: We should only remove ren1_src in the base2466 * stage and in other_stage (think of rename +2467 * add-source case).2468 */2469remove_file(o,1, ren1_src,2470 renamed_stage ==2|| !was_tracked(o, ren1_src));24712472oidcpy(&src_other.oid,2473&ren1->src_entry->stages[other_stage].oid);2474 src_other.mode = ren1->src_entry->stages[other_stage].mode;2475oidcpy(&dst_other.oid,2476&ren1->dst_entry->stages[other_stage].oid);2477 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2478 try_merge =0;24792480if(oid_eq(&src_other.oid, &null_oid) &&2481 ren1->add_turned_into_rename) {2482setup_rename_conflict_info(RENAME_DIR,2483 ren1->pair,2484 NULL,2485 branch1,2486 branch2,2487 ren1->dst_entry,2488 NULL,2489 o,2490 NULL,2491 NULL);2492}else if(oid_eq(&src_other.oid, &null_oid)) {2493setup_rename_conflict_info(RENAME_DELETE,2494 ren1->pair,2495 NULL,2496 branch1,2497 branch2,2498 ren1->dst_entry,2499 NULL,2500 o,2501 NULL,2502 NULL);2503}else if((dst_other.mode == ren1->pair->two->mode) &&2504oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2505/*2506 * Added file on the other side identical to2507 * the file being renamed: clean merge.2508 * Also, there is no need to overwrite the2509 * file already in the working copy, so call2510 * update_file_flags() instead of2511 * update_file().2512 */2513if(update_file_flags(o,2514&ren1->pair->two->oid,2515 ren1->pair->two->mode,2516 ren1_dst,25171,/* update_cache */25180/* update_wd */))2519 clean_merge = -1;2520}else if(!oid_eq(&dst_other.oid, &null_oid)) {2521 clean_merge =0;2522 try_merge =1;2523output(o,1,_("CONFLICT (rename/add): Rename%s->%sin%s. "2524"%sadded in%s"),2525 ren1_src, ren1_dst, branch1,2526 ren1_dst, branch2);2527if(o->call_depth) {2528struct merge_file_info mfi;2529if(merge_file_one(o, ren1_dst, &null_oid,0,2530&ren1->pair->two->oid,2531 ren1->pair->two->mode,2532&dst_other.oid,2533 dst_other.mode,2534 branch1, branch2, &mfi)) {2535 clean_merge = -1;2536goto cleanup_and_return;2537}2538output(o,1,_("Adding merged%s"), ren1_dst);2539if(update_file(o,0, &mfi.oid,2540 mfi.mode, ren1_dst))2541 clean_merge = -1;2542 try_merge =0;2543}else{2544char*new_path =unique_path(o, ren1_dst, branch2);2545output(o,1,_("Adding as%sinstead"), new_path);2546if(update_file(o,0, &dst_other.oid,2547 dst_other.mode, new_path))2548 clean_merge = -1;2549free(new_path);2550}2551}else2552 try_merge =1;25532554if(clean_merge <0)2555goto cleanup_and_return;2556if(try_merge) {2557struct diff_filespec *one, *a, *b;2558 src_other.path = (char*)ren1_src;25592560 one = ren1->pair->one;2561if(a_renames == renames1) {2562 a = ren1->pair->two;2563 b = &src_other;2564}else{2565 b = ren1->pair->two;2566 a = &src_other;2567}2568update_entry(ren1->dst_entry, one, a, b);2569setup_rename_conflict_info(RENAME_NORMAL,2570 ren1->pair,2571 NULL,2572 branch1,2573 NULL,2574 ren1->dst_entry,2575 NULL,2576 o,2577 NULL,2578 NULL);2579}2580}2581}2582cleanup_and_return:2583string_list_clear(&a_by_dst,0);2584string_list_clear(&b_by_dst,0);25852586return clean_merge;2587}25882589struct rename_info {2590struct string_list *head_renames;2591struct string_list *merge_renames;2592};25932594static voidinitial_cleanup_rename(struct diff_queue_struct *pairs,2595struct hashmap *dir_renames)2596{2597struct hashmap_iter iter;2598struct dir_rename_entry *e;25992600hashmap_iter_init(dir_renames, &iter);2601while((e =hashmap_iter_next(&iter))) {2602free(e->dir);2603strbuf_release(&e->new_dir);2604/* possible_new_dirs already cleared in get_directory_renames */2605}2606hashmap_free(dir_renames,1);2607free(dir_renames);26082609free(pairs->queue);2610free(pairs);2611}26122613static inthandle_renames(struct merge_options *o,2614struct tree *common,2615struct tree *head,2616struct tree *merge,2617struct string_list *entries,2618struct rename_info *ri)2619{2620struct diff_queue_struct *head_pairs, *merge_pairs;2621struct hashmap *dir_re_head, *dir_re_merge;2622int clean =1;26232624 ri->head_renames = NULL;2625 ri->merge_renames = NULL;26262627if(!o->detect_rename)2628return1;26292630 head_pairs =get_diffpairs(o, common, head);2631 merge_pairs =get_diffpairs(o, common, merge);26322633 dir_re_head =get_directory_renames(head_pairs, head);2634 dir_re_merge =get_directory_renames(merge_pairs, merge);26352636handle_directory_level_conflicts(o,2637 dir_re_head, head,2638 dir_re_merge, merge);26392640 ri->head_renames =get_renames(o, head_pairs,2641 dir_re_merge, dir_re_head, head,2642 common, head, merge, entries,2643&clean);2644if(clean <0)2645goto cleanup;2646 ri->merge_renames =get_renames(o, merge_pairs,2647 dir_re_head, dir_re_merge, merge,2648 common, head, merge, entries,2649&clean);2650if(clean <0)2651goto cleanup;2652 clean &=process_renames(o, ri->head_renames, ri->merge_renames);26532654cleanup:2655/*2656 * Some cleanup is deferred until cleanup_renames() because the2657 * data structures are still needed and referenced in2658 * process_entry(). But there are a few things we can free now.2659 */2660initial_cleanup_rename(head_pairs, dir_re_head);2661initial_cleanup_rename(merge_pairs, dir_re_merge);26622663return clean;2664}26652666static voidfinal_cleanup_rename(struct string_list *rename)2667{2668const struct rename *re;2669int i;26702671if(rename == NULL)2672return;26732674for(i =0; i < rename->nr; i++) {2675 re = rename->items[i].util;2676diff_free_filepair(re->pair);2677}2678string_list_clear(rename,1);2679free(rename);2680}26812682static voidfinal_cleanup_renames(struct rename_info *re_info)2683{2684final_cleanup_rename(re_info->head_renames);2685final_cleanup_rename(re_info->merge_renames);2686}26872688static struct object_id *stage_oid(const struct object_id *oid,unsigned mode)2689{2690return(is_null_oid(oid) || mode ==0) ? NULL: (struct object_id *)oid;2691}26922693static intread_oid_strbuf(struct merge_options *o,2694const struct object_id *oid,struct strbuf *dst)2695{2696void*buf;2697enum object_type type;2698unsigned long size;2699 buf =read_object_file(oid, &type, &size);2700if(!buf)2701returnerr(o,_("cannot read object%s"),oid_to_hex(oid));2702if(type != OBJ_BLOB) {2703free(buf);2704returnerr(o,_("object%sis not a blob"),oid_to_hex(oid));2705}2706strbuf_attach(dst, buf, size, size +1);2707return0;2708}27092710static intblob_unchanged(struct merge_options *opt,2711const struct object_id *o_oid,2712unsigned o_mode,2713const struct object_id *a_oid,2714unsigned a_mode,2715int renormalize,const char*path)2716{2717struct strbuf o = STRBUF_INIT;2718struct strbuf a = STRBUF_INIT;2719int ret =0;/* assume changed for safety */27202721if(a_mode != o_mode)2722return0;2723if(oid_eq(o_oid, a_oid))2724return1;2725if(!renormalize)2726return0;27272728assert(o_oid && a_oid);2729if(read_oid_strbuf(opt, o_oid, &o) ||read_oid_strbuf(opt, a_oid, &a))2730goto error_return;2731/*2732 * Note: binary | is used so that both renormalizations are2733 * performed. Comparison can be skipped if both files are2734 * unchanged since their sha1s have already been compared.2735 */2736if(renormalize_buffer(&the_index, path, o.buf, o.len, &o) |2737renormalize_buffer(&the_index, path, a.buf, a.len, &a))2738 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));27392740error_return:2741strbuf_release(&o);2742strbuf_release(&a);2743return ret;2744}27452746static inthandle_modify_delete(struct merge_options *o,2747const char*path,2748struct object_id *o_oid,int o_mode,2749struct object_id *a_oid,int a_mode,2750struct object_id *b_oid,int b_mode)2751{2752const char*modify_branch, *delete_branch;2753struct object_id *changed_oid;2754int changed_mode;27552756if(a_oid) {2757 modify_branch = o->branch1;2758 delete_branch = o->branch2;2759 changed_oid = a_oid;2760 changed_mode = a_mode;2761}else{2762 modify_branch = o->branch2;2763 delete_branch = o->branch1;2764 changed_oid = b_oid;2765 changed_mode = b_mode;2766}27672768returnhandle_change_delete(o,2769 path, NULL,2770 o_oid, o_mode,2771 changed_oid, changed_mode,2772 modify_branch, delete_branch,2773_("modify"),_("modified"));2774}27752776static intmerge_content(struct merge_options *o,2777const char*path,2778int is_dirty,2779struct object_id *o_oid,int o_mode,2780struct object_id *a_oid,int a_mode,2781struct object_id *b_oid,int b_mode,2782struct rename_conflict_info *rename_conflict_info)2783{2784const char*reason =_("content");2785const char*path1 = NULL, *path2 = NULL;2786struct merge_file_info mfi;2787struct diff_filespec one, a, b;2788unsigned df_conflict_remains =0;27892790if(!o_oid) {2791 reason =_("add/add");2792 o_oid = (struct object_id *)&null_oid;2793}2794 one.path = a.path = b.path = (char*)path;2795oidcpy(&one.oid, o_oid);2796 one.mode = o_mode;2797oidcpy(&a.oid, a_oid);2798 a.mode = a_mode;2799oidcpy(&b.oid, b_oid);2800 b.mode = b_mode;28012802if(rename_conflict_info) {2803struct diff_filepair *pair1 = rename_conflict_info->pair1;28042805 path1 = (o->branch1 == rename_conflict_info->branch1) ?2806 pair1->two->path : pair1->one->path;2807/* If rename_conflict_info->pair2 != NULL, we are in2808 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a2809 * normal rename.2810 */2811 path2 = (rename_conflict_info->pair2 ||2812 o->branch2 == rename_conflict_info->branch1) ?2813 pair1->two->path : pair1->one->path;28142815if(dir_in_way(path, !o->call_depth,2816S_ISGITLINK(pair1->two->mode)))2817 df_conflict_remains =1;2818}2819if(merge_file_special_markers(o, &one, &a, &b, path,2820 o->branch1, path1,2821 o->branch2, path2, &mfi))2822return-1;28232824if(mfi.clean && !df_conflict_remains &&2825oid_eq(&mfi.oid, a_oid) && mfi.mode == a_mode) {2826int path_renamed_outside_HEAD;2827output(o,3,_("Skipped%s(merged same as existing)"), path);2828/*2829 * The content merge resulted in the same file contents we2830 * already had. We can return early if those file contents2831 * are recorded at the correct path (which may not be true2832 * if the merge involves a rename).2833 */2834 path_renamed_outside_HEAD = !path2 || !strcmp(path, path2);2835if(!path_renamed_outside_HEAD) {2836if(add_cacheinfo(o, mfi.mode, &mfi.oid, path,28370, (!o->call_depth && !is_dirty),0))2838return-1;2839return mfi.clean;2840}2841}28422843if(!mfi.clean) {2844if(S_ISGITLINK(mfi.mode))2845 reason =_("submodule");2846output(o,1,_("CONFLICT (%s): Merge conflict in%s"),2847 reason, path);2848if(rename_conflict_info && !df_conflict_remains)2849if(update_stages(o, path, &one, &a, &b))2850return-1;2851}28522853if(df_conflict_remains || is_dirty) {2854char*new_path;2855if(o->call_depth) {2856remove_file_from_cache(path);2857}else{2858if(!mfi.clean) {2859if(update_stages(o, path, &one, &a, &b))2860return-1;2861}else{2862int file_from_stage2 =was_tracked(o, path);2863struct diff_filespec merged;2864oidcpy(&merged.oid, &mfi.oid);2865 merged.mode = mfi.mode;28662867if(update_stages(o, path, NULL,2868 file_from_stage2 ? &merged : NULL,2869 file_from_stage2 ? NULL : &merged))2870return-1;2871}28722873}2874 new_path =unique_path(o, path, rename_conflict_info->branch1);2875if(is_dirty) {2876output(o,1,_("Refusing to lose dirty file at%s"),2877 path);2878}2879output(o,1,_("Adding as%sinstead"), new_path);2880if(update_file(o,0, &mfi.oid, mfi.mode, new_path)) {2881free(new_path);2882return-1;2883}2884free(new_path);2885 mfi.clean =0;2886}else if(update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))2887return-1;2888return!is_dirty && mfi.clean;2889}28902891static intconflict_rename_normal(struct merge_options *o,2892const char*path,2893struct object_id *o_oid,unsigned int o_mode,2894struct object_id *a_oid,unsigned int a_mode,2895struct object_id *b_oid,unsigned int b_mode,2896struct rename_conflict_info *ci)2897{2898/* Merge the content and write it out */2899returnmerge_content(o, path,was_dirty(o, path),2900 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,2901 ci);2902}29032904/* Per entry merge function */2905static intprocess_entry(struct merge_options *o,2906const char*path,struct stage_data *entry)2907{2908int clean_merge =1;2909int normalize = o->renormalize;2910unsigned o_mode = entry->stages[1].mode;2911unsigned a_mode = entry->stages[2].mode;2912unsigned b_mode = entry->stages[3].mode;2913struct object_id *o_oid =stage_oid(&entry->stages[1].oid, o_mode);2914struct object_id *a_oid =stage_oid(&entry->stages[2].oid, a_mode);2915struct object_id *b_oid =stage_oid(&entry->stages[3].oid, b_mode);29162917 entry->processed =1;2918if(entry->rename_conflict_info) {2919struct rename_conflict_info *conflict_info = entry->rename_conflict_info;2920switch(conflict_info->rename_type) {2921case RENAME_NORMAL:2922case RENAME_ONE_FILE_TO_ONE:2923 clean_merge =conflict_rename_normal(o,2924 path,2925 o_oid, o_mode,2926 a_oid, a_mode,2927 b_oid, b_mode,2928 conflict_info);2929break;2930case RENAME_DIR:2931 clean_merge =1;2932if(conflict_rename_dir(o,2933 conflict_info->pair1,2934 conflict_info->branch1,2935 conflict_info->branch2))2936 clean_merge = -1;2937break;2938case RENAME_DELETE:2939 clean_merge =0;2940if(conflict_rename_delete(o,2941 conflict_info->pair1,2942 conflict_info->branch1,2943 conflict_info->branch2))2944 clean_merge = -1;2945break;2946case RENAME_ONE_FILE_TO_TWO:2947 clean_merge =0;2948if(conflict_rename_rename_1to2(o, conflict_info))2949 clean_merge = -1;2950break;2951case RENAME_TWO_FILES_TO_ONE:2952 clean_merge =0;2953if(conflict_rename_rename_2to1(o, conflict_info))2954 clean_merge = -1;2955break;2956default:2957 entry->processed =0;2958break;2959}2960}else if(o_oid && (!a_oid || !b_oid)) {2961/* Case A: Deleted in one */2962if((!a_oid && !b_oid) ||2963(!b_oid &&blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||2964(!a_oid &&blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {2965/* Deleted in both or deleted in one and2966 * unchanged in the other */2967if(a_oid)2968output(o,2,_("Removing%s"), path);2969/* do not touch working file if it did not exist */2970remove_file(o,1, path, !a_oid);2971}else{2972/* Modify/delete; deleted side may have put a directory in the way */2973 clean_merge =0;2974if(handle_modify_delete(o, path, o_oid, o_mode,2975 a_oid, a_mode, b_oid, b_mode))2976 clean_merge = -1;2977}2978}else if((!o_oid && a_oid && !b_oid) ||2979(!o_oid && !a_oid && b_oid)) {2980/* Case B: Added in one. */2981/* [nothing|directory] -> ([nothing|directory], file) */29822983const char*add_branch;2984const char*other_branch;2985unsigned mode;2986const struct object_id *oid;2987const char*conf;29882989if(a_oid) {2990 add_branch = o->branch1;2991 other_branch = o->branch2;2992 mode = a_mode;2993 oid = a_oid;2994 conf =_("file/directory");2995}else{2996 add_branch = o->branch2;2997 other_branch = o->branch1;2998 mode = b_mode;2999 oid = b_oid;3000 conf =_("directory/file");3001}3002if(dir_in_way(path,3003!o->call_depth && !S_ISGITLINK(a_mode),30040)) {3005char*new_path =unique_path(o, path, add_branch);3006 clean_merge =0;3007output(o,1,_("CONFLICT (%s): There is a directory with name%sin%s. "3008"Adding%sas%s"),3009 conf, path, other_branch, path, new_path);3010if(update_file(o,0, oid, mode, new_path))3011 clean_merge = -1;3012else if(o->call_depth)3013remove_file_from_cache(path);3014free(new_path);3015}else{3016output(o,2,_("Adding%s"), path);3017/* do not overwrite file if already present */3018if(update_file_flags(o, oid, mode, path,1, !a_oid))3019 clean_merge = -1;3020}3021}else if(a_oid && b_oid) {3022/* Case C: Added in both (check for same permissions) and */3023/* case D: Modified in both, but differently. */3024int is_dirty =0;/* unpack_trees would have bailed if dirty */3025 clean_merge =merge_content(o, path, is_dirty,3026 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3027 NULL);3028}else if(!o_oid && !a_oid && !b_oid) {3029/*3030 * this entry was deleted altogether. a_mode == 0 means3031 * we had that path and want to actively remove it.3032 */3033remove_file(o,1, path, !a_mode);3034}else3035die("BUG: fatal merge failure, shouldn't happen.");30363037return clean_merge;3038}30393040intmerge_trees(struct merge_options *o,3041struct tree *head,3042struct tree *merge,3043struct tree *common,3044struct tree **result)3045{3046int code, clean;30473048if(o->subtree_shift) {3049 merge =shift_tree_object(head, merge, o->subtree_shift);3050 common =shift_tree_object(head, common, o->subtree_shift);3051}30523053if(oid_eq(&common->object.oid, &merge->object.oid)) {3054struct strbuf sb = STRBUF_INIT;30553056if(!o->call_depth &&index_has_changes(&sb)) {3057err(o,_("Dirty index: cannot merge (dirty:%s)"),3058 sb.buf);3059return0;3060}3061output(o,0,_("Already up to date!"));3062*result = head;3063return1;3064}30653066 code =git_merge_trees(o, common, head, merge);30673068if(code !=0) {3069if(show(o,4) || o->call_depth)3070err(o,_("merging of trees%sand%sfailed"),3071oid_to_hex(&head->object.oid),3072oid_to_hex(&merge->object.oid));3073return-1;3074}30753076if(unmerged_cache()) {3077struct string_list *entries;3078struct rename_info re_info;3079int i;3080/*3081 * Only need the hashmap while processing entries, so3082 * initialize it here and free it when we are done running3083 * through the entries. Keeping it in the merge_options as3084 * opposed to decaring a local hashmap is for convenience3085 * so that we don't have to pass it to around.3086 */3087hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL,512);3088get_files_dirs(o, head);3089get_files_dirs(o, merge);30903091 entries =get_unmerged();3092 clean =handle_renames(o, common, head, merge, entries,3093&re_info);3094record_df_conflict_files(o, entries);3095if(clean <0)3096goto cleanup;3097for(i = entries->nr-1;0<= i; i--) {3098const char*path = entries->items[i].string;3099struct stage_data *e = entries->items[i].util;3100if(!e->processed) {3101int ret =process_entry(o, path, e);3102if(!ret)3103 clean =0;3104else if(ret <0) {3105 clean = ret;3106goto cleanup;3107}3108}3109}3110for(i =0; i < entries->nr; i++) {3111struct stage_data *e = entries->items[i].util;3112if(!e->processed)3113die("BUG: unprocessed path???%s",3114 entries->items[i].string);3115}31163117cleanup:3118final_cleanup_renames(&re_info);31193120string_list_clear(entries,1);3121free(entries);31223123hashmap_free(&o->current_file_dir_set,1);31243125if(clean <0)3126return clean;3127}3128else3129 clean =1;31303131/* Free the extra index left from git_merge_trees() */3132/*3133 * FIXME: Need to also free data allocated by3134 * setup_unpack_trees_porcelain() tucked away in o->unpack_opts.msgs,3135 * but the problem is that only half of it refers to dynamically3136 * allocated data, while the other half points at static strings.3137 */3138discard_index(&o->orig_index);31393140if(o->call_depth && !(*result =write_tree_from_memory(o)))3141return-1;31423143return clean;3144}31453146static struct commit_list *reverse_commit_list(struct commit_list *list)3147{3148struct commit_list *next = NULL, *current, *backup;3149for(current = list; current; current = backup) {3150 backup = current->next;3151 current->next = next;3152 next = current;3153}3154return next;3155}31563157/*3158 * Merge the commits h1 and h2, return the resulting virtual3159 * commit object and a flag indicating the cleanness of the merge.3160 */3161intmerge_recursive(struct merge_options *o,3162struct commit *h1,3163struct commit *h2,3164struct commit_list *ca,3165struct commit **result)3166{3167struct commit_list *iter;3168struct commit *merged_common_ancestors;3169struct tree *mrtree;3170int clean;31713172if(show(o,4)) {3173output(o,4,_("Merging:"));3174output_commit_title(o, h1);3175output_commit_title(o, h2);3176}31773178if(!ca) {3179 ca =get_merge_bases(h1, h2);3180 ca =reverse_commit_list(ca);3181}31823183if(show(o,5)) {3184unsigned cnt =commit_list_count(ca);31853186output(o,5,Q_("found%ucommon ancestor:",3187"found%ucommon ancestors:", cnt), cnt);3188for(iter = ca; iter; iter = iter->next)3189output_commit_title(o, iter->item);3190}31913192 merged_common_ancestors =pop_commit(&ca);3193if(merged_common_ancestors == NULL) {3194/* if there is no common ancestor, use an empty tree */3195struct tree *tree;31963197 tree =lookup_tree(the_hash_algo->empty_tree);3198 merged_common_ancestors =make_virtual_commit(tree,"ancestor");3199}32003201for(iter = ca; iter; iter = iter->next) {3202const char*saved_b1, *saved_b2;3203 o->call_depth++;3204/*3205 * When the merge fails, the result contains files3206 * with conflict markers. The cleanness flag is3207 * ignored (unless indicating an error), it was never3208 * actually used, as result of merge_trees has always3209 * overwritten it: the committed "conflicts" were3210 * already resolved.3211 */3212discard_cache();3213 saved_b1 = o->branch1;3214 saved_b2 = o->branch2;3215 o->branch1 ="Temporary merge branch 1";3216 o->branch2 ="Temporary merge branch 2";3217if(merge_recursive(o, merged_common_ancestors, iter->item,3218 NULL, &merged_common_ancestors) <0)3219return-1;3220 o->branch1 = saved_b1;3221 o->branch2 = saved_b2;3222 o->call_depth--;32233224if(!merged_common_ancestors)3225returnerr(o,_("merge returned no commit"));3226}32273228discard_cache();3229if(!o->call_depth)3230read_cache();32313232 o->ancestor ="merged common ancestors";3233 clean =merge_trees(o, h1->tree, h2->tree, merged_common_ancestors->tree,3234&mrtree);3235if(clean <0) {3236flush_output(o);3237return clean;3238}32393240if(o->call_depth) {3241*result =make_virtual_commit(mrtree,"merged tree");3242commit_list_insert(h1, &(*result)->parents);3243commit_list_insert(h2, &(*result)->parents->next);3244}3245flush_output(o);3246if(!o->call_depth && o->buffer_output <2)3247strbuf_release(&o->obuf);3248if(show(o,2))3249diff_warn_rename_limit("merge.renamelimit",3250 o->needed_rename_limit,0);3251return clean;3252}32533254static struct commit *get_ref(const struct object_id *oid,const char*name)3255{3256struct object *object;32573258 object =deref_tag(parse_object(oid), name,strlen(name));3259if(!object)3260return NULL;3261if(object->type == OBJ_TREE)3262returnmake_virtual_commit((struct tree*)object, name);3263if(object->type != OBJ_COMMIT)3264return NULL;3265if(parse_commit((struct commit *)object))3266return NULL;3267return(struct commit *)object;3268}32693270intmerge_recursive_generic(struct merge_options *o,3271const struct object_id *head,3272const struct object_id *merge,3273int num_base_list,3274const struct object_id **base_list,3275struct commit **result)3276{3277int clean;3278struct lock_file lock = LOCK_INIT;3279struct commit *head_commit =get_ref(head, o->branch1);3280struct commit *next_commit =get_ref(merge, o->branch2);3281struct commit_list *ca = NULL;32823283if(base_list) {3284int i;3285for(i =0; i < num_base_list; ++i) {3286struct commit *base;3287if(!(base =get_ref(base_list[i],oid_to_hex(base_list[i]))))3288returnerr(o,_("Could not parse object '%s'"),3289oid_to_hex(base_list[i]));3290commit_list_insert(base, &ca);3291}3292}32933294hold_locked_index(&lock, LOCK_DIE_ON_ERROR);3295 clean =merge_recursive(o, head_commit, next_commit, ca,3296 result);3297if(clean <0) {3298rollback_lock_file(&lock);3299return clean;3300}33013302if(write_locked_index(&the_index, &lock,3303 COMMIT_LOCK | SKIP_IF_UNCHANGED))3304returnerr(o,_("Unable to write index."));33053306return clean ?0:1;3307}33083309static voidmerge_recursive_config(struct merge_options *o)3310{3311git_config_get_int("merge.verbosity", &o->verbosity);3312git_config_get_int("diff.renamelimit", &o->diff_rename_limit);3313git_config_get_int("merge.renamelimit", &o->merge_rename_limit);3314git_config(git_xmerge_config, NULL);3315}33163317voidinit_merge_options(struct merge_options *o)3318{3319const char*merge_verbosity;3320memset(o,0,sizeof(struct merge_options));3321 o->verbosity =2;3322 o->buffer_output =1;3323 o->diff_rename_limit = -1;3324 o->merge_rename_limit = -1;3325 o->renormalize =0;3326 o->detect_rename =1;3327merge_recursive_config(o);3328 merge_verbosity =getenv("GIT_MERGE_VERBOSITY");3329if(merge_verbosity)3330 o->verbosity =strtol(merge_verbosity, NULL,10);3331if(o->verbosity >=5)3332 o->buffer_output =0;3333strbuf_init(&o->obuf,0);3334string_list_init(&o->df_conflict_file_set,1);3335}33363337intparse_merge_opt(struct merge_options *o,const char*s)3338{3339const char*arg;33403341if(!s || !*s)3342return-1;3343if(!strcmp(s,"ours"))3344 o->recursive_variant = MERGE_RECURSIVE_OURS;3345else if(!strcmp(s,"theirs"))3346 o->recursive_variant = MERGE_RECURSIVE_THEIRS;3347else if(!strcmp(s,"subtree"))3348 o->subtree_shift ="";3349else if(skip_prefix(s,"subtree=", &arg))3350 o->subtree_shift = arg;3351else if(!strcmp(s,"patience"))3352 o->xdl_opts =DIFF_WITH_ALG(o, PATIENCE_DIFF);3353else if(!strcmp(s,"histogram"))3354 o->xdl_opts =DIFF_WITH_ALG(o, HISTOGRAM_DIFF);3355else if(skip_prefix(s,"diff-algorithm=", &arg)) {3356long value =parse_algorithm_value(arg);3357if(value <0)3358return-1;3359/* clear out previous settings */3360DIFF_XDL_CLR(o, NEED_MINIMAL);3361 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3362 o->xdl_opts |= value;3363}3364else if(!strcmp(s,"ignore-space-change"))3365DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);3366else if(!strcmp(s,"ignore-all-space"))3367DIFF_XDL_SET(o, IGNORE_WHITESPACE);3368else if(!strcmp(s,"ignore-space-at-eol"))3369DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);3370else if(!strcmp(s,"ignore-cr-at-eol"))3371DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);3372else if(!strcmp(s,"renormalize"))3373 o->renormalize =1;3374else if(!strcmp(s,"no-renormalize"))3375 o->renormalize =0;3376else if(!strcmp(s,"no-renames"))3377 o->detect_rename =0;3378else if(!strcmp(s,"find-renames")) {3379 o->detect_rename =1;3380 o->rename_score =0;3381}3382else if(skip_prefix(s,"find-renames=", &arg) ||3383skip_prefix(s,"rename-threshold=", &arg)) {3384if((o->rename_score =parse_rename_score(&arg)) == -1|| *arg !=0)3385return-1;3386 o->detect_rename =1;3387}3388else3389return-1;3390return0;3391}