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#include"revision.h" 27 28struct path_hashmap_entry { 29struct hashmap_entry e; 30char path[FLEX_ARRAY]; 31}; 32 33static intpath_hashmap_cmp(const void*cmp_data, 34const void*entry, 35const void*entry_or_key, 36const void*keydata) 37{ 38const struct path_hashmap_entry *a = entry; 39const struct path_hashmap_entry *b = entry_or_key; 40const char*key = keydata; 41 42if(ignore_case) 43returnstrcasecmp(a->path, key ? key : b->path); 44else 45returnstrcmp(a->path, key ? key : b->path); 46} 47 48static unsigned intpath_hash(const char*path) 49{ 50return ignore_case ?strihash(path) :strhash(path); 51} 52 53static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap, 54char*dir) 55{ 56struct dir_rename_entry key; 57 58if(dir == NULL) 59return NULL; 60hashmap_entry_init(&key,strhash(dir)); 61 key.dir = dir; 62returnhashmap_get(hashmap, &key, NULL); 63} 64 65static intdir_rename_cmp(const void*unused_cmp_data, 66const void*entry, 67const void*entry_or_key, 68const void*unused_keydata) 69{ 70const struct dir_rename_entry *e1 = entry; 71const struct dir_rename_entry *e2 = entry_or_key; 72 73returnstrcmp(e1->dir, e2->dir); 74} 75 76static voiddir_rename_init(struct hashmap *map) 77{ 78hashmap_init(map, dir_rename_cmp, NULL,0); 79} 80 81static voiddir_rename_entry_init(struct dir_rename_entry *entry, 82char*directory) 83{ 84hashmap_entry_init(entry,strhash(directory)); 85 entry->dir = directory; 86 entry->non_unique_new_dir =0; 87strbuf_init(&entry->new_dir,0); 88string_list_init(&entry->possible_new_dirs,0); 89} 90 91static struct collision_entry *collision_find_entry(struct hashmap *hashmap, 92char*target_file) 93{ 94struct collision_entry key; 95 96hashmap_entry_init(&key,strhash(target_file)); 97 key.target_file = target_file; 98returnhashmap_get(hashmap, &key, NULL); 99} 100 101static intcollision_cmp(void*unused_cmp_data, 102const struct collision_entry *e1, 103const struct collision_entry *e2, 104const void*unused_keydata) 105{ 106returnstrcmp(e1->target_file, e2->target_file); 107} 108 109static voidcollision_init(struct hashmap *map) 110{ 111hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL,0); 112} 113 114static voidflush_output(struct merge_options *o) 115{ 116if(o->buffer_output <2&& o->obuf.len) { 117fputs(o->obuf.buf, stdout); 118strbuf_reset(&o->obuf); 119} 120} 121 122static interr(struct merge_options *o,const char*err, ...) 123{ 124va_list params; 125 126if(o->buffer_output <2) 127flush_output(o); 128else{ 129strbuf_complete(&o->obuf,'\n'); 130strbuf_addstr(&o->obuf,"error: "); 131} 132va_start(params, err); 133strbuf_vaddf(&o->obuf, err, params); 134va_end(params); 135if(o->buffer_output >1) 136strbuf_addch(&o->obuf,'\n'); 137else{ 138error("%s", o->obuf.buf); 139strbuf_reset(&o->obuf); 140} 141 142return-1; 143} 144 145static struct tree *shift_tree_object(struct tree *one,struct tree *two, 146const char*subtree_shift) 147{ 148struct object_id shifted; 149 150if(!*subtree_shift) { 151shift_tree(&one->object.oid, &two->object.oid, &shifted,0); 152}else{ 153shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 154 subtree_shift); 155} 156if(!oidcmp(&two->object.oid, &shifted)) 157return two; 158returnlookup_tree(&shifted); 159} 160 161static struct commit *make_virtual_commit(struct tree *tree,const char*comment) 162{ 163struct commit *commit =alloc_commit_node(); 164 165set_merge_remote_desc(commit, comment, (struct object *)commit); 166 commit->maybe_tree = tree; 167 commit->object.parsed =1; 168return commit; 169} 170 171/* 172 * Since we use get_tree_entry(), which does not put the read object into 173 * the object pool, we cannot rely on a == b. 174 */ 175static intoid_eq(const struct object_id *a,const struct object_id *b) 176{ 177if(!a && !b) 178return2; 179return a && b &&oidcmp(a, b) ==0; 180} 181 182enum rename_type { 183 RENAME_NORMAL =0, 184 RENAME_DIR, 185 RENAME_DELETE, 186 RENAME_ONE_FILE_TO_ONE, 187 RENAME_ONE_FILE_TO_TWO, 188 RENAME_TWO_FILES_TO_ONE 189}; 190 191struct rename_conflict_info { 192enum rename_type rename_type; 193struct diff_filepair *pair1; 194struct diff_filepair *pair2; 195const char*branch1; 196const char*branch2; 197struct stage_data *dst_entry1; 198struct stage_data *dst_entry2; 199struct diff_filespec ren1_other; 200struct diff_filespec ren2_other; 201}; 202 203/* 204 * Since we want to write the index eventually, we cannot reuse the index 205 * for these (temporary) data. 206 */ 207struct stage_data { 208struct{ 209unsigned mode; 210struct object_id oid; 211} stages[4]; 212struct rename_conflict_info *rename_conflict_info; 213unsigned processed:1; 214}; 215 216staticinlinevoidsetup_rename_conflict_info(enum rename_type rename_type, 217struct diff_filepair *pair1, 218struct diff_filepair *pair2, 219const char*branch1, 220const char*branch2, 221struct stage_data *dst_entry1, 222struct stage_data *dst_entry2, 223struct merge_options *o, 224struct stage_data *src_entry1, 225struct stage_data *src_entry2) 226{ 227struct rename_conflict_info *ci =xcalloc(1,sizeof(struct rename_conflict_info)); 228 ci->rename_type = rename_type; 229 ci->pair1 = pair1; 230 ci->branch1 = branch1; 231 ci->branch2 = branch2; 232 233 ci->dst_entry1 = dst_entry1; 234 dst_entry1->rename_conflict_info = ci; 235 dst_entry1->processed =0; 236 237assert(!pair2 == !dst_entry2); 238if(dst_entry2) { 239 ci->dst_entry2 = dst_entry2; 240 ci->pair2 = pair2; 241 dst_entry2->rename_conflict_info = ci; 242} 243 244if(rename_type == RENAME_TWO_FILES_TO_ONE) { 245/* 246 * For each rename, there could have been 247 * modifications on the side of history where that 248 * file was not renamed. 249 */ 250int ostage1 = o->branch1 == branch1 ?3:2; 251int ostage2 = ostage1 ^1; 252 253 ci->ren1_other.path = pair1->one->path; 254oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid); 255 ci->ren1_other.mode = src_entry1->stages[ostage1].mode; 256 257 ci->ren2_other.path = pair2->one->path; 258oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid); 259 ci->ren2_other.mode = src_entry2->stages[ostage2].mode; 260} 261} 262 263static intshow(struct merge_options *o,int v) 264{ 265return(!o->call_depth && o->verbosity >= v) || o->verbosity >=5; 266} 267 268__attribute__((format(printf,3,4))) 269static voidoutput(struct merge_options *o,int v,const char*fmt, ...) 270{ 271va_list ap; 272 273if(!show(o, v)) 274return; 275 276strbuf_addchars(&o->obuf,' ', o->call_depth *2); 277 278va_start(ap, fmt); 279strbuf_vaddf(&o->obuf, fmt, ap); 280va_end(ap); 281 282strbuf_addch(&o->obuf,'\n'); 283if(!o->buffer_output) 284flush_output(o); 285} 286 287static voidoutput_commit_title(struct merge_options *o,struct commit *commit) 288{ 289struct merge_remote_desc *desc; 290 291strbuf_addchars(&o->obuf,' ', o->call_depth *2); 292 desc =merge_remote_util(commit); 293if(desc) 294strbuf_addf(&o->obuf,"virtual%s\n", desc->name); 295else{ 296strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid, 297 DEFAULT_ABBREV); 298strbuf_addch(&o->obuf,' '); 299if(parse_commit(commit) !=0) 300strbuf_addstr(&o->obuf,_("(bad commit)\n")); 301else{ 302const char*title; 303const char*msg =get_commit_buffer(commit, NULL); 304int len =find_commit_subject(msg, &title); 305if(len) 306strbuf_addf(&o->obuf,"%.*s\n", len, title); 307unuse_commit_buffer(commit, msg); 308} 309} 310flush_output(o); 311} 312 313static intadd_cacheinfo(struct merge_options *o, 314unsigned int mode,const struct object_id *oid, 315const char*path,int stage,int refresh,int options) 316{ 317struct cache_entry *ce; 318int ret; 319 320 ce =make_cache_entry(mode, oid ? oid->hash : null_sha1, path, stage,0); 321if(!ce) 322returnerr(o,_("add_cacheinfo failed for path '%s'; merge aborting."), path); 323 324 ret =add_cache_entry(ce, options); 325if(refresh) { 326struct cache_entry *nce; 327 328 nce =refresh_cache_entry(ce, CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 329if(!nce) 330returnerr(o,_("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); 331if(nce != ce) 332 ret =add_cache_entry(nce, options); 333} 334return ret; 335} 336 337static voidinit_tree_desc_from_tree(struct tree_desc *desc,struct tree *tree) 338{ 339parse_tree(tree); 340init_tree_desc(desc, tree->buffer, tree->size); 341} 342 343static intunpack_trees_start(struct merge_options *o, 344struct tree *common, 345struct tree *head, 346struct tree *merge) 347{ 348int rc; 349struct tree_desc t[3]; 350struct index_state tmp_index = { NULL }; 351 352memset(&o->unpack_opts,0,sizeof(o->unpack_opts)); 353if(o->call_depth) 354 o->unpack_opts.index_only =1; 355else 356 o->unpack_opts.update =1; 357 o->unpack_opts.merge =1; 358 o->unpack_opts.head_idx =2; 359 o->unpack_opts.fn = threeway_merge; 360 o->unpack_opts.src_index = &the_index; 361 o->unpack_opts.dst_index = &tmp_index; 362 o->unpack_opts.aggressive = !merge_detect_rename(o); 363setup_unpack_trees_porcelain(&o->unpack_opts,"merge"); 364 365init_tree_desc_from_tree(t+0, common); 366init_tree_desc_from_tree(t+1, head); 367init_tree_desc_from_tree(t+2, merge); 368 369 rc =unpack_trees(3, t, &o->unpack_opts); 370cache_tree_free(&active_cache_tree); 371 372/* 373 * Update the_index to match the new results, AFTER saving a copy 374 * in o->orig_index. Update src_index to point to the saved copy. 375 * (verify_uptodate() checks src_index, and the original index is 376 * the one that had the necessary modification timestamps.) 377 */ 378 o->orig_index = the_index; 379 the_index = tmp_index; 380 o->unpack_opts.src_index = &o->orig_index; 381 382return rc; 383} 384 385static voidunpack_trees_finish(struct merge_options *o) 386{ 387discard_index(&o->orig_index); 388clear_unpack_trees_porcelain(&o->unpack_opts); 389} 390 391struct tree *write_tree_from_memory(struct merge_options *o) 392{ 393struct tree *result = NULL; 394 395if(unmerged_cache()) { 396int i; 397fprintf(stderr,"BUG: There are unmerged index entries:\n"); 398for(i =0; i < active_nr; i++) { 399const struct cache_entry *ce = active_cache[i]; 400if(ce_stage(ce)) 401fprintf(stderr,"BUG:%d%.*s\n",ce_stage(ce), 402(int)ce_namelen(ce), ce->name); 403} 404BUG("unmerged index entries in merge-recursive.c"); 405} 406 407if(!active_cache_tree) 408 active_cache_tree =cache_tree(); 409 410if(!cache_tree_fully_valid(active_cache_tree) && 411cache_tree_update(&the_index,0) <0) { 412err(o,_("error building trees")); 413return NULL; 414} 415 416 result =lookup_tree(&active_cache_tree->oid); 417 418return result; 419} 420 421static intsave_files_dirs(const struct object_id *oid, 422struct strbuf *base,const char*path, 423unsigned int mode,int stage,void*context) 424{ 425struct path_hashmap_entry *entry; 426int baselen = base->len; 427struct merge_options *o = context; 428 429strbuf_addstr(base, path); 430 431FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 432hashmap_entry_init(entry,path_hash(entry->path)); 433hashmap_add(&o->current_file_dir_set, entry); 434 435strbuf_setlen(base, baselen); 436return(S_ISDIR(mode) ? READ_TREE_RECURSIVE :0); 437} 438 439static voidget_files_dirs(struct merge_options *o,struct tree *tree) 440{ 441struct pathspec match_all; 442memset(&match_all,0,sizeof(match_all)); 443read_tree_recursive(tree,"",0,0, &match_all, save_files_dirs, o); 444} 445 446static intget_tree_entry_if_blob(const struct object_id *tree, 447const char*path, 448struct object_id *hashy, 449unsigned int*mode_o) 450{ 451int ret; 452 453 ret =get_tree_entry(tree, path, hashy, mode_o); 454if(S_ISDIR(*mode_o)) { 455oidcpy(hashy, &null_oid); 456*mode_o =0; 457} 458return ret; 459} 460 461/* 462 * Returns an index_entry instance which doesn't have to correspond to 463 * a real cache entry in Git's index. 464 */ 465static struct stage_data *insert_stage_data(const char*path, 466struct tree *o,struct tree *a,struct tree *b, 467struct string_list *entries) 468{ 469struct string_list_item *item; 470struct stage_data *e =xcalloc(1,sizeof(struct stage_data)); 471get_tree_entry_if_blob(&o->object.oid, path, 472&e->stages[1].oid, &e->stages[1].mode); 473get_tree_entry_if_blob(&a->object.oid, path, 474&e->stages[2].oid, &e->stages[2].mode); 475get_tree_entry_if_blob(&b->object.oid, path, 476&e->stages[3].oid, &e->stages[3].mode); 477 item =string_list_insert(entries, path); 478 item->util = e; 479return e; 480} 481 482/* 483 * Create a dictionary mapping file names to stage_data objects. The 484 * dictionary contains one entry for every path with a non-zero stage entry. 485 */ 486static struct string_list *get_unmerged(void) 487{ 488struct string_list *unmerged =xcalloc(1,sizeof(struct string_list)); 489int i; 490 491 unmerged->strdup_strings =1; 492 493for(i =0; i < active_nr; i++) { 494struct string_list_item *item; 495struct stage_data *e; 496const struct cache_entry *ce = active_cache[i]; 497if(!ce_stage(ce)) 498continue; 499 500 item =string_list_lookup(unmerged, ce->name); 501if(!item) { 502 item =string_list_insert(unmerged, ce->name); 503 item->util =xcalloc(1,sizeof(struct stage_data)); 504} 505 e = item->util; 506 e->stages[ce_stage(ce)].mode = ce->ce_mode; 507oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 508} 509 510return unmerged; 511} 512 513static intstring_list_df_name_compare(const char*one,const char*two) 514{ 515int onelen =strlen(one); 516int twolen =strlen(two); 517/* 518 * Here we only care that entries for D/F conflicts are 519 * adjacent, in particular with the file of the D/F conflict 520 * appearing before files below the corresponding directory. 521 * The order of the rest of the list is irrelevant for us. 522 * 523 * To achieve this, we sort with df_name_compare and provide 524 * the mode S_IFDIR so that D/F conflicts will sort correctly. 525 * We use the mode S_IFDIR for everything else for simplicity, 526 * since in other cases any changes in their order due to 527 * sorting cause no problems for us. 528 */ 529int cmp =df_name_compare(one, onelen, S_IFDIR, 530 two, twolen, S_IFDIR); 531/* 532 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 533 * that 'foo' comes before 'foo/bar'. 534 */ 535if(cmp) 536return cmp; 537return onelen - twolen; 538} 539 540static voidrecord_df_conflict_files(struct merge_options *o, 541struct string_list *entries) 542{ 543/* If there is a D/F conflict and the file for such a conflict 544 * currently exist in the working tree, we want to allow it to be 545 * removed to make room for the corresponding directory if needed. 546 * The files underneath the directories of such D/F conflicts will 547 * be processed before the corresponding file involved in the D/F 548 * conflict. If the D/F directory ends up being removed by the 549 * merge, then we won't have to touch the D/F file. If the D/F 550 * directory needs to be written to the working copy, then the D/F 551 * file will simply be removed (in make_room_for_path()) to make 552 * room for the necessary paths. Note that if both the directory 553 * and the file need to be present, then the D/F file will be 554 * reinstated with a new unique name at the time it is processed. 555 */ 556struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 557const char*last_file = NULL; 558int last_len =0; 559int i; 560 561/* 562 * If we're merging merge-bases, we don't want to bother with 563 * any working directory changes. 564 */ 565if(o->call_depth) 566return; 567 568/* Ensure D/F conflicts are adjacent in the entries list. */ 569for(i =0; i < entries->nr; i++) { 570struct string_list_item *next = &entries->items[i]; 571string_list_append(&df_sorted_entries, next->string)->util = 572 next->util; 573} 574 df_sorted_entries.cmp = string_list_df_name_compare; 575string_list_sort(&df_sorted_entries); 576 577string_list_clear(&o->df_conflict_file_set,1); 578for(i =0; i < df_sorted_entries.nr; i++) { 579const char*path = df_sorted_entries.items[i].string; 580int len =strlen(path); 581struct stage_data *e = df_sorted_entries.items[i].util; 582 583/* 584 * Check if last_file & path correspond to a D/F conflict; 585 * i.e. whether path is last_file+'/'+<something>. 586 * If so, record that it's okay to remove last_file to make 587 * room for path and friends if needed. 588 */ 589if(last_file && 590 len > last_len && 591memcmp(path, last_file, last_len) ==0&& 592 path[last_len] =='/') { 593string_list_insert(&o->df_conflict_file_set, last_file); 594} 595 596/* 597 * Determine whether path could exist as a file in the 598 * working directory as a possible D/F conflict. This 599 * will only occur when it exists in stage 2 as a 600 * file. 601 */ 602if(S_ISREG(e->stages[2].mode) ||S_ISLNK(e->stages[2].mode)) { 603 last_file = path; 604 last_len = len; 605}else{ 606 last_file = NULL; 607} 608} 609string_list_clear(&df_sorted_entries,0); 610} 611 612struct rename { 613struct diff_filepair *pair; 614/* 615 * Purpose of src_entry and dst_entry: 616 * 617 * If 'before' is renamed to 'after' then src_entry will contain 618 * the versions of 'before' from the merge_base, HEAD, and MERGE in 619 * stages 1, 2, and 3; dst_entry will contain the respective 620 * versions of 'after' in corresponding locations. Thus, we have a 621 * total of six modes and oids, though some will be null. (Stage 0 622 * is ignored; we're interested in handling conflicts.) 623 * 624 * Since we don't turn on break-rewrites by default, neither 625 * src_entry nor dst_entry can have all three of their stages have 626 * non-null oids, meaning at most four of the six will be non-null. 627 * Also, since this is a rename, both src_entry and dst_entry will 628 * have at least one non-null oid, meaning at least two will be 629 * non-null. Of the six oids, a typical rename will have three be 630 * non-null. Only two implies a rename/delete, and four implies a 631 * rename/add. 632 */ 633struct stage_data *src_entry; 634struct stage_data *dst_entry; 635unsigned add_turned_into_rename:1; 636unsigned processed:1; 637}; 638 639static intupdate_stages(struct merge_options *opt,const char*path, 640const struct diff_filespec *o, 641const struct diff_filespec *a, 642const struct diff_filespec *b) 643{ 644 645/* 646 * NOTE: It is usually a bad idea to call update_stages on a path 647 * before calling update_file on that same path, since it can 648 * sometimes lead to spurious "refusing to lose untracked file..." 649 * messages from update_file (via make_room_for path via 650 * would_lose_untracked). Instead, reverse the order of the calls 651 * (executing update_file first and then update_stages). 652 */ 653int clear =1; 654int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 655if(clear) 656if(remove_file_from_cache(path)) 657return-1; 658if(o) 659if(add_cacheinfo(opt, o->mode, &o->oid, path,1,0, options)) 660return-1; 661if(a) 662if(add_cacheinfo(opt, a->mode, &a->oid, path,2,0, options)) 663return-1; 664if(b) 665if(add_cacheinfo(opt, b->mode, &b->oid, path,3,0, options)) 666return-1; 667return0; 668} 669 670static intupdate_stages_for_stage_data(struct merge_options *opt, 671const char*path, 672const struct stage_data *stage_data) 673{ 674struct diff_filespec o, a, b; 675 676 o.mode = stage_data->stages[1].mode; 677oidcpy(&o.oid, &stage_data->stages[1].oid); 678 679 a.mode = stage_data->stages[2].mode; 680oidcpy(&a.oid, &stage_data->stages[2].oid); 681 682 b.mode = stage_data->stages[3].mode; 683oidcpy(&b.oid, &stage_data->stages[3].oid); 684 685returnupdate_stages(opt, path, 686is_null_oid(&o.oid) ? NULL : &o, 687is_null_oid(&a.oid) ? NULL : &a, 688is_null_oid(&b.oid) ? NULL : &b); 689} 690 691static voidupdate_entry(struct stage_data *entry, 692struct diff_filespec *o, 693struct diff_filespec *a, 694struct diff_filespec *b) 695{ 696 entry->processed =0; 697 entry->stages[1].mode = o->mode; 698 entry->stages[2].mode = a->mode; 699 entry->stages[3].mode = b->mode; 700oidcpy(&entry->stages[1].oid, &o->oid); 701oidcpy(&entry->stages[2].oid, &a->oid); 702oidcpy(&entry->stages[3].oid, &b->oid); 703} 704 705static intremove_file(struct merge_options *o,int clean, 706const char*path,int no_wd) 707{ 708int update_cache = o->call_depth || clean; 709int update_working_directory = !o->call_depth && !no_wd; 710 711if(update_cache) { 712if(remove_file_from_cache(path)) 713return-1; 714} 715if(update_working_directory) { 716if(ignore_case) { 717struct cache_entry *ce; 718 ce =cache_file_exists(path,strlen(path), ignore_case); 719if(ce &&ce_stage(ce) ==0&&strcmp(path, ce->name)) 720return0; 721} 722if(remove_path(path)) 723return-1; 724} 725return0; 726} 727 728/* add a string to a strbuf, but converting "/" to "_" */ 729static voidadd_flattened_path(struct strbuf *out,const char*s) 730{ 731size_t i = out->len; 732strbuf_addstr(out, s); 733for(; i < out->len; i++) 734if(out->buf[i] =='/') 735 out->buf[i] ='_'; 736} 737 738static char*unique_path(struct merge_options *o,const char*path,const char*branch) 739{ 740struct path_hashmap_entry *entry; 741struct strbuf newpath = STRBUF_INIT; 742int suffix =0; 743size_t base_len; 744 745strbuf_addf(&newpath,"%s~", path); 746add_flattened_path(&newpath, branch); 747 748 base_len = newpath.len; 749while(hashmap_get_from_hash(&o->current_file_dir_set, 750path_hash(newpath.buf), newpath.buf) || 751(!o->call_depth &&file_exists(newpath.buf))) { 752strbuf_setlen(&newpath, base_len); 753strbuf_addf(&newpath,"_%d", suffix++); 754} 755 756FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 757hashmap_entry_init(entry,path_hash(entry->path)); 758hashmap_add(&o->current_file_dir_set, entry); 759returnstrbuf_detach(&newpath, NULL); 760} 761 762/** 763 * Check whether a directory in the index is in the way of an incoming 764 * file. Return 1 if so. If check_working_copy is non-zero, also 765 * check the working directory. If empty_ok is non-zero, also return 766 * 0 in the case where the working-tree dir exists but is empty. 767 */ 768static intdir_in_way(const char*path,int check_working_copy,int empty_ok) 769{ 770int pos; 771struct strbuf dirpath = STRBUF_INIT; 772struct stat st; 773 774strbuf_addstr(&dirpath, path); 775strbuf_addch(&dirpath,'/'); 776 777 pos =cache_name_pos(dirpath.buf, dirpath.len); 778 779if(pos <0) 780 pos = -1- pos; 781if(pos < active_nr && 782!strncmp(dirpath.buf, active_cache[pos]->name, dirpath.len)) { 783strbuf_release(&dirpath); 784return1; 785} 786 787strbuf_release(&dirpath); 788return check_working_copy && !lstat(path, &st) &&S_ISDIR(st.st_mode) && 789!(empty_ok &&is_empty_dir(path)); 790} 791 792/* 793 * Returns whether path was tracked in the index before the merge started, 794 * and its oid and mode match the specified values 795 */ 796static intwas_tracked_and_matches(struct merge_options *o,const char*path, 797const struct object_id *oid,unsigned mode) 798{ 799int pos =index_name_pos(&o->orig_index, path,strlen(path)); 800struct cache_entry *ce; 801 802if(0> pos) 803/* we were not tracking this path before the merge */ 804return0; 805 806/* See if the file we were tracking before matches */ 807 ce = o->orig_index.cache[pos]; 808return(oid_eq(&ce->oid, oid) && ce->ce_mode == mode); 809} 810 811/* 812 * Returns whether path was tracked in the index before the merge started 813 */ 814static intwas_tracked(struct merge_options *o,const char*path) 815{ 816int pos =index_name_pos(&o->orig_index, path,strlen(path)); 817 818if(0<= pos) 819/* we were tracking this path before the merge */ 820return1; 821 822return0; 823} 824 825static intwould_lose_untracked(const char*path) 826{ 827/* 828 * This may look like it can be simplified to: 829 * return !was_tracked(o, path) && file_exists(path) 830 * but it can't. This function needs to know whether path was in 831 * the working tree due to EITHER having been tracked in the index 832 * before the merge OR having been put into the working copy and 833 * index by unpack_trees(). Due to that either-or requirement, we 834 * check the current index instead of the original one. 835 * 836 * Note that we do not need to worry about merge-recursive itself 837 * updating the index after unpack_trees() and before calling this 838 * function, because we strictly require all code paths in 839 * merge-recursive to update the working tree first and the index 840 * second. Doing otherwise would break 841 * update_file()/would_lose_untracked(); see every comment in this 842 * file which mentions "update_stages". 843 */ 844int pos =cache_name_pos(path,strlen(path)); 845 846if(pos <0) 847 pos = -1- pos; 848while(pos < active_nr && 849!strcmp(path, active_cache[pos]->name)) { 850/* 851 * If stage #0, it is definitely tracked. 852 * If it has stage #2 then it was tracked 853 * before this merge started. All other 854 * cases the path was not tracked. 855 */ 856switch(ce_stage(active_cache[pos])) { 857case0: 858case2: 859return0; 860} 861 pos++; 862} 863returnfile_exists(path); 864} 865 866static intwas_dirty(struct merge_options *o,const char*path) 867{ 868struct cache_entry *ce; 869int dirty =1; 870 871if(o->call_depth || !was_tracked(o, path)) 872return!dirty; 873 874 ce =index_file_exists(o->unpack_opts.src_index, 875 path,strlen(path), ignore_case); 876 dirty =verify_uptodate(ce, &o->unpack_opts) !=0; 877return dirty; 878} 879 880static intmake_room_for_path(struct merge_options *o,const char*path) 881{ 882int status, i; 883const char*msg =_("failed to create path '%s'%s"); 884 885/* Unlink any D/F conflict files that are in the way */ 886for(i =0; i < o->df_conflict_file_set.nr; i++) { 887const char*df_path = o->df_conflict_file_set.items[i].string; 888size_t pathlen =strlen(path); 889size_t df_pathlen =strlen(df_path); 890if(df_pathlen < pathlen && 891 path[df_pathlen] =='/'&& 892strncmp(path, df_path, df_pathlen) ==0) { 893output(o,3, 894_("Removing%sto make room for subdirectory\n"), 895 df_path); 896unlink(df_path); 897unsorted_string_list_delete_item(&o->df_conflict_file_set, 898 i,0); 899break; 900} 901} 902 903/* Make sure leading directories are created */ 904 status =safe_create_leading_directories_const(path); 905if(status) { 906if(status == SCLD_EXISTS) 907/* something else exists */ 908returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 909returnerr(o, msg, path,""); 910} 911 912/* 913 * Do not unlink a file in the work tree if we are not 914 * tracking it. 915 */ 916if(would_lose_untracked(path)) 917returnerr(o,_("refusing to lose untracked file at '%s'"), 918 path); 919 920/* Successful unlink is good.. */ 921if(!unlink(path)) 922return0; 923/* .. and so is no existing file */ 924if(errno == ENOENT) 925return0; 926/* .. but not some other error (who really cares what?) */ 927returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 928} 929 930static intupdate_file_flags(struct merge_options *o, 931const struct object_id *oid, 932unsigned mode, 933const char*path, 934int update_cache, 935int update_wd) 936{ 937int ret =0; 938 939if(o->call_depth) 940 update_wd =0; 941 942if(update_wd) { 943enum object_type type; 944void*buf; 945unsigned long size; 946 947if(S_ISGITLINK(mode)) { 948/* 949 * We may later decide to recursively descend into 950 * the submodule directory and update its index 951 * and/or work tree, but we do not do that now. 952 */ 953 update_wd =0; 954goto update_index; 955} 956 957 buf =read_object_file(oid, &type, &size); 958if(!buf) 959returnerr(o,_("cannot read object%s'%s'"),oid_to_hex(oid), path); 960if(type != OBJ_BLOB) { 961 ret =err(o,_("blob expected for%s'%s'"),oid_to_hex(oid), path); 962goto free_buf; 963} 964if(S_ISREG(mode)) { 965struct strbuf strbuf = STRBUF_INIT; 966if(convert_to_working_tree(path, buf, size, &strbuf)) { 967free(buf); 968 size = strbuf.len; 969 buf =strbuf_detach(&strbuf, NULL); 970} 971} 972 973if(make_room_for_path(o, path) <0) { 974 update_wd =0; 975goto free_buf; 976} 977if(S_ISREG(mode) || (!has_symlinks &&S_ISLNK(mode))) { 978int fd; 979if(mode &0100) 980 mode =0777; 981else 982 mode =0666; 983 fd =open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 984if(fd <0) { 985 ret =err(o,_("failed to open '%s':%s"), 986 path,strerror(errno)); 987goto free_buf; 988} 989write_in_full(fd, buf, size); 990close(fd); 991}else if(S_ISLNK(mode)) { 992char*lnk =xmemdupz(buf, size); 993safe_create_leading_directories_const(path); 994unlink(path); 995if(symlink(lnk, path)) 996 ret =err(o,_("failed to symlink '%s':%s"), 997 path,strerror(errno)); 998free(lnk); 999}else1000 ret =err(o,1001_("do not know what to do with%06o%s'%s'"),1002 mode,oid_to_hex(oid), path);1003 free_buf:1004free(buf);1005}1006 update_index:1007if(!ret && update_cache)1008if(add_cacheinfo(o, mode, oid, path,0, update_wd,1009 ADD_CACHE_OK_TO_ADD))1010return-1;1011return ret;1012}10131014static intupdate_file(struct merge_options *o,1015int clean,1016const struct object_id *oid,1017unsigned mode,1018const char*path)1019{1020returnupdate_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth);1021}10221023/* Low level file merging, update and removal */10241025struct merge_file_info {1026struct object_id oid;1027unsigned mode;1028unsigned clean:1,1029 merge:1;1030};10311032static intmerge_3way(struct merge_options *o,1033 mmbuffer_t *result_buf,1034const struct diff_filespec *one,1035const struct diff_filespec *a,1036const struct diff_filespec *b,1037const char*branch1,1038const char*branch2)1039{1040 mmfile_t orig, src1, src2;1041struct ll_merge_options ll_opts = {0};1042char*base_name, *name1, *name2;1043int merge_status;10441045 ll_opts.renormalize = o->renormalize;1046 ll_opts.xdl_opts = o->xdl_opts;10471048if(o->call_depth) {1049 ll_opts.virtual_ancestor =1;1050 ll_opts.variant =0;1051}else{1052switch(o->recursive_variant) {1053case MERGE_RECURSIVE_OURS:1054 ll_opts.variant = XDL_MERGE_FAVOR_OURS;1055break;1056case MERGE_RECURSIVE_THEIRS:1057 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;1058break;1059default:1060 ll_opts.variant =0;1061break;1062}1063}10641065if(strcmp(a->path, b->path) ||1066(o->ancestor != NULL &&strcmp(a->path, one->path) !=0)) {1067 base_name = o->ancestor == NULL ? NULL :1068mkpathdup("%s:%s", o->ancestor, one->path);1069 name1 =mkpathdup("%s:%s", branch1, a->path);1070 name2 =mkpathdup("%s:%s", branch2, b->path);1071}else{1072 base_name = o->ancestor == NULL ? NULL :1073mkpathdup("%s", o->ancestor);1074 name1 =mkpathdup("%s", branch1);1075 name2 =mkpathdup("%s", branch2);1076}10771078read_mmblob(&orig, &one->oid);1079read_mmblob(&src1, &a->oid);1080read_mmblob(&src2, &b->oid);10811082 merge_status =ll_merge(result_buf, a->path, &orig, base_name,1083&src1, name1, &src2, name2, &ll_opts);10841085free(base_name);1086free(name1);1087free(name2);1088free(orig.ptr);1089free(src1.ptr);1090free(src2.ptr);1091return merge_status;1092}10931094static intfind_first_merges(struct object_array *result,const char*path,1095struct commit *a,struct commit *b)1096{1097int i, j;1098struct object_array merges = OBJECT_ARRAY_INIT;1099struct commit *commit;1100int contains_another;11011102char merged_revision[42];1103const char*rev_args[] = {"rev-list","--merges","--ancestry-path",1104"--all", merged_revision, NULL };1105struct rev_info revs;1106struct setup_revision_opt rev_opts;11071108memset(result,0,sizeof(struct object_array));1109memset(&rev_opts,0,sizeof(rev_opts));11101111/* get all revisions that merge commit a */1112xsnprintf(merged_revision,sizeof(merged_revision),"^%s",1113oid_to_hex(&a->object.oid));1114init_revisions(&revs, NULL);1115 rev_opts.submodule = path;1116/* FIXME: can't handle linked worktrees in submodules yet */1117 revs.single_worktree = path != NULL;1118setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);11191120/* save all revisions from the above list that contain b */1121if(prepare_revision_walk(&revs))1122die("revision walk setup failed");1123while((commit =get_revision(&revs)) != NULL) {1124struct object *o = &(commit->object);1125if(in_merge_bases(b, commit))1126add_object_array(o, NULL, &merges);1127}1128reset_revision_walk();11291130/* Now we've got all merges that contain a and b. Prune all1131 * merges that contain another found merge and save them in1132 * result.1133 */1134for(i =0; i < merges.nr; i++) {1135struct commit *m1 = (struct commit *) merges.objects[i].item;11361137 contains_another =0;1138for(j =0; j < merges.nr; j++) {1139struct commit *m2 = (struct commit *) merges.objects[j].item;1140if(i != j &&in_merge_bases(m2, m1)) {1141 contains_another =1;1142break;1143}1144}11451146if(!contains_another)1147add_object_array(merges.objects[i].item, NULL, result);1148}11491150object_array_clear(&merges);1151return result->nr;1152}11531154static voidprint_commit(struct commit *commit)1155{1156struct strbuf sb = STRBUF_INIT;1157struct pretty_print_context ctx = {0};1158 ctx.date_mode.type = DATE_NORMAL;1159format_commit_message(commit,"%h:%m %s", &sb, &ctx);1160fprintf(stderr,"%s\n", sb.buf);1161strbuf_release(&sb);1162}11631164static intmerge_submodule(struct merge_options *o,1165struct object_id *result,const char*path,1166const struct object_id *base,const struct object_id *a,1167const struct object_id *b)1168{1169struct commit *commit_base, *commit_a, *commit_b;1170int parent_count;1171struct object_array merges;11721173int i;1174int search = !o->call_depth;11751176/* store a in result in case we fail */1177oidcpy(result, a);11781179/* we can not handle deletion conflicts */1180if(is_null_oid(base))1181return0;1182if(is_null_oid(a))1183return0;1184if(is_null_oid(b))1185return0;11861187if(add_submodule_odb(path)) {1188output(o,1,_("Failed to merge submodule%s(not checked out)"), path);1189return0;1190}11911192if(!(commit_base =lookup_commit_reference(base)) ||1193!(commit_a =lookup_commit_reference(a)) ||1194!(commit_b =lookup_commit_reference(b))) {1195output(o,1,_("Failed to merge submodule%s(commits not present)"), path);1196return0;1197}11981199/* check whether both changes are forward */1200if(!in_merge_bases(commit_base, commit_a) ||1201!in_merge_bases(commit_base, commit_b)) {1202output(o,1,_("Failed to merge submodule%s(commits don't follow merge-base)"), path);1203return0;1204}12051206/* Case #1: a is contained in b or vice versa */1207if(in_merge_bases(commit_a, commit_b)) {1208oidcpy(result, b);1209if(show(o,3)) {1210output(o,3,_("Fast-forwarding submodule%sto the following commit:"), path);1211output_commit_title(o, commit_b);1212}else if(show(o,2))1213output(o,2,_("Fast-forwarding submodule%s"), path);1214else1215;/* no output */12161217return1;1218}1219if(in_merge_bases(commit_b, commit_a)) {1220oidcpy(result, a);1221if(show(o,3)) {1222output(o,3,_("Fast-forwarding submodule%sto the following commit:"), path);1223output_commit_title(o, commit_a);1224}else if(show(o,2))1225output(o,2,_("Fast-forwarding submodule%s"), path);1226else1227;/* no output */12281229return1;1230}12311232/*1233 * Case #2: There are one or more merges that contain a and b in1234 * the submodule. If there is only one, then present it as a1235 * suggestion to the user, but leave it marked unmerged so the1236 * user needs to confirm the resolution.1237 */12381239/* Skip the search if makes no sense to the calling context. */1240if(!search)1241return0;12421243/* find commit which merges them */1244 parent_count =find_first_merges(&merges, path, commit_a, commit_b);1245switch(parent_count) {1246case0:1247output(o,1,_("Failed to merge submodule%s(merge following commits not found)"), path);1248break;12491250case1:1251output(o,1,_("Failed to merge submodule%s(not fast-forward)"), path);1252output(o,2,_("Found a possible merge resolution for the submodule:\n"));1253print_commit((struct commit *) merges.objects[0].item);1254output(o,2,_(1255"If this is correct simply add it to the index "1256"for example\n"1257"by using:\n\n"1258" git update-index --cacheinfo 160000%s\"%s\"\n\n"1259"which will accept this suggestion.\n"),1260oid_to_hex(&merges.objects[0].item->oid), path);1261break;12621263default:1264output(o,1,_("Failed to merge submodule%s(multiple merges found)"), path);1265for(i =0; i < merges.nr; i++)1266print_commit((struct commit *) merges.objects[i].item);1267}12681269object_array_clear(&merges);1270return0;1271}12721273static intmerge_file_1(struct merge_options *o,1274const struct diff_filespec *one,1275const struct diff_filespec *a,1276const struct diff_filespec *b,1277const char*filename,1278const char*branch1,1279const char*branch2,1280struct merge_file_info *result)1281{1282 result->merge =0;1283 result->clean =1;12841285if((S_IFMT & a->mode) != (S_IFMT & b->mode)) {1286 result->clean =0;1287if(S_ISREG(a->mode)) {1288 result->mode = a->mode;1289oidcpy(&result->oid, &a->oid);1290}else{1291 result->mode = b->mode;1292oidcpy(&result->oid, &b->oid);1293}1294}else{1295if(!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))1296 result->merge =1;12971298/*1299 * Merge modes1300 */1301if(a->mode == b->mode || a->mode == one->mode)1302 result->mode = b->mode;1303else{1304 result->mode = a->mode;1305if(b->mode != one->mode) {1306 result->clean =0;1307 result->merge =1;1308}1309}13101311if(oid_eq(&a->oid, &b->oid) ||oid_eq(&a->oid, &one->oid))1312oidcpy(&result->oid, &b->oid);1313else if(oid_eq(&b->oid, &one->oid))1314oidcpy(&result->oid, &a->oid);1315else if(S_ISREG(a->mode)) {1316 mmbuffer_t result_buf;1317int ret =0, merge_status;13181319 merge_status =merge_3way(o, &result_buf, one, a, b,1320 branch1, branch2);13211322if((merge_status <0) || !result_buf.ptr)1323 ret =err(o,_("Failed to execute internal merge"));13241325if(!ret &&1326write_object_file(result_buf.ptr, result_buf.size,1327 blob_type, &result->oid))1328 ret =err(o,_("Unable to add%sto database"),1329 a->path);13301331free(result_buf.ptr);1332if(ret)1333return ret;1334 result->clean = (merge_status ==0);1335}else if(S_ISGITLINK(a->mode)) {1336 result->clean =merge_submodule(o, &result->oid,1337 one->path,1338&one->oid,1339&a->oid,1340&b->oid);1341}else if(S_ISLNK(a->mode)) {1342switch(o->recursive_variant) {1343case MERGE_RECURSIVE_NORMAL:1344oidcpy(&result->oid, &a->oid);1345if(!oid_eq(&a->oid, &b->oid))1346 result->clean =0;1347break;1348case MERGE_RECURSIVE_OURS:1349oidcpy(&result->oid, &a->oid);1350break;1351case MERGE_RECURSIVE_THEIRS:1352oidcpy(&result->oid, &b->oid);1353break;1354}1355}else1356BUG("unsupported object type in the tree");1357}13581359if(result->merge)1360output(o,2,_("Auto-merging%s"), filename);13611362return0;1363}13641365static intmerge_file_special_markers(struct merge_options *o,1366const struct diff_filespec *one,1367const struct diff_filespec *a,1368const struct diff_filespec *b,1369const char*target_filename,1370const char*branch1,1371const char*filename1,1372const char*branch2,1373const char*filename2,1374struct merge_file_info *mfi)1375{1376char*side1 = NULL;1377char*side2 = NULL;1378int ret;13791380if(filename1)1381 side1 =xstrfmt("%s:%s", branch1, filename1);1382if(filename2)1383 side2 =xstrfmt("%s:%s", branch2, filename2);13841385 ret =merge_file_1(o, one, a, b, target_filename,1386 side1 ? side1 : branch1,1387 side2 ? side2 : branch2, mfi);13881389free(side1);1390free(side2);1391return ret;1392}13931394static intmerge_file_one(struct merge_options *o,1395const char*path,1396const struct object_id *o_oid,int o_mode,1397const struct object_id *a_oid,int a_mode,1398const struct object_id *b_oid,int b_mode,1399const char*branch1,1400const char*branch2,1401struct merge_file_info *mfi)1402{1403struct diff_filespec one, a, b;14041405 one.path = a.path = b.path = (char*)path;1406oidcpy(&one.oid, o_oid);1407 one.mode = o_mode;1408oidcpy(&a.oid, a_oid);1409 a.mode = a_mode;1410oidcpy(&b.oid, b_oid);1411 b.mode = b_mode;1412returnmerge_file_1(o, &one, &a, &b, path, branch1, branch2, mfi);1413}14141415static intconflict_rename_dir(struct merge_options *o,1416struct diff_filepair *pair,1417const char*rename_branch,1418const char*other_branch)1419{1420const struct diff_filespec *dest = pair->two;14211422if(!o->call_depth &&would_lose_untracked(dest->path)) {1423char*alt_path =unique_path(o, dest->path, rename_branch);14241425output(o,1,_("Error: Refusing to lose untracked file at%s; "1426"writing to%sinstead."),1427 dest->path, alt_path);1428/*1429 * Write the file in worktree at alt_path, but not in the1430 * index. Instead, write to dest->path for the index but1431 * only at the higher appropriate stage.1432 */1433if(update_file(o,0, &dest->oid, dest->mode, alt_path))1434return-1;1435free(alt_path);1436returnupdate_stages(o, dest->path, NULL,1437 rename_branch == o->branch1 ? dest : NULL,1438 rename_branch == o->branch1 ? NULL : dest);1439}14401441/* Update dest->path both in index and in worktree */1442if(update_file(o,1, &dest->oid, dest->mode, dest->path))1443return-1;1444return0;1445}14461447static inthandle_change_delete(struct merge_options *o,1448const char*path,const char*old_path,1449const struct object_id *o_oid,int o_mode,1450const struct object_id *changed_oid,1451int changed_mode,1452const char*change_branch,1453const char*delete_branch,1454const char*change,const char*change_past)1455{1456char*alt_path = NULL;1457const char*update_path = path;1458int ret =0;14591460if(dir_in_way(path, !o->call_depth,0) ||1461(!o->call_depth &&would_lose_untracked(path))) {1462 update_path = alt_path =unique_path(o, path, change_branch);1463}14641465if(o->call_depth) {1466/*1467 * We cannot arbitrarily accept either a_sha or b_sha as1468 * correct; since there is no true "middle point" between1469 * them, simply reuse the base version for virtual merge base.1470 */1471 ret =remove_file_from_cache(path);1472if(!ret)1473 ret =update_file(o,0, o_oid, o_mode, update_path);1474}else{1475if(!alt_path) {1476if(!old_path) {1477output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1478"and%sin%s. Version%sof%sleft in tree."),1479 change, path, delete_branch, change_past,1480 change_branch, change_branch, path);1481}else{1482output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1483"and%sto%sin%s. Version%sof%sleft in tree."),1484 change, old_path, delete_branch, change_past, path,1485 change_branch, change_branch, path);1486}1487}else{1488if(!old_path) {1489output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1490"and%sin%s. Version%sof%sleft in tree at%s."),1491 change, path, delete_branch, change_past,1492 change_branch, change_branch, path, alt_path);1493}else{1494output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1495"and%sto%sin%s. Version%sof%sleft in tree at%s."),1496 change, old_path, delete_branch, change_past, path,1497 change_branch, change_branch, path, alt_path);1498}1499}1500/*1501 * No need to call update_file() on path when change_branch ==1502 * o->branch1 && !alt_path, since that would needlessly touch1503 * path. We could call update_file_flags() with update_cache=01504 * and update_wd=0, but that's a no-op.1505 */1506if(change_branch != o->branch1 || alt_path)1507 ret =update_file(o,0, changed_oid, changed_mode, update_path);1508}1509free(alt_path);15101511return ret;1512}15131514static intconflict_rename_delete(struct merge_options *o,1515struct diff_filepair *pair,1516const char*rename_branch,1517const char*delete_branch)1518{1519const struct diff_filespec *orig = pair->one;1520const struct diff_filespec *dest = pair->two;15211522if(handle_change_delete(o,1523 o->call_depth ? orig->path : dest->path,1524 o->call_depth ? NULL : orig->path,1525&orig->oid, orig->mode,1526&dest->oid, dest->mode,1527 rename_branch, delete_branch,1528_("rename"),_("renamed")))1529return-1;15301531if(o->call_depth)1532returnremove_file_from_cache(dest->path);1533else1534returnupdate_stages(o, dest->path, NULL,1535 rename_branch == o->branch1 ? dest : NULL,1536 rename_branch == o->branch1 ? NULL : dest);1537}15381539static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,1540struct stage_data *entry,1541int stage)1542{1543struct object_id *oid = &entry->stages[stage].oid;1544unsigned mode = entry->stages[stage].mode;1545if(mode ==0||is_null_oid(oid))1546return NULL;1547oidcpy(&target->oid, oid);1548 target->mode = mode;1549return target;1550}15511552static inthandle_file(struct merge_options *o,1553struct diff_filespec *rename,1554int stage,1555struct rename_conflict_info *ci)1556{1557char*dst_name = rename->path;1558struct stage_data *dst_entry;1559const char*cur_branch, *other_branch;1560struct diff_filespec other;1561struct diff_filespec *add;1562int ret;15631564if(stage ==2) {1565 dst_entry = ci->dst_entry1;1566 cur_branch = ci->branch1;1567 other_branch = ci->branch2;1568}else{1569 dst_entry = ci->dst_entry2;1570 cur_branch = ci->branch2;1571 other_branch = ci->branch1;1572}15731574 add =filespec_from_entry(&other, dst_entry, stage ^1);1575if(add) {1576int ren_src_was_dirty =was_dirty(o, rename->path);1577char*add_name =unique_path(o, rename->path, other_branch);1578if(update_file(o,0, &add->oid, add->mode, add_name))1579return-1;15801581if(ren_src_was_dirty) {1582output(o,1,_("Refusing to lose dirty file at%s"),1583 rename->path);1584}1585/*1586 * Because the double negatives somehow keep confusing me...1587 * 1) update_wd iff !ren_src_was_dirty.1588 * 2) no_wd iff !update_wd1589 * 3) so, no_wd == !!ren_src_was_dirty == ren_src_was_dirty1590 */1591remove_file(o,0, rename->path, ren_src_was_dirty);1592 dst_name =unique_path(o, rename->path, cur_branch);1593}else{1594if(dir_in_way(rename->path, !o->call_depth,0)) {1595 dst_name =unique_path(o, rename->path, cur_branch);1596output(o,1,_("%sis a directory in%sadding as%sinstead"),1597 rename->path, other_branch, dst_name);1598}else if(!o->call_depth &&1599would_lose_untracked(rename->path)) {1600 dst_name =unique_path(o, rename->path, cur_branch);1601output(o,1,_("Refusing to lose untracked file at%s; "1602"adding as%sinstead"),1603 rename->path, dst_name);1604}1605}1606if((ret =update_file(o,0, &rename->oid, rename->mode, dst_name)))1607;/* fall through, do allow dst_name to be released */1608else if(stage ==2)1609 ret =update_stages(o, rename->path, NULL, rename, add);1610else1611 ret =update_stages(o, rename->path, NULL, add, rename);16121613if(dst_name != rename->path)1614free(dst_name);16151616return ret;1617}16181619static intconflict_rename_rename_1to2(struct merge_options *o,1620struct rename_conflict_info *ci)1621{1622/* One file was renamed in both branches, but to different names. */1623struct diff_filespec *one = ci->pair1->one;1624struct diff_filespec *a = ci->pair1->two;1625struct diff_filespec *b = ci->pair2->two;16261627output(o,1,_("CONFLICT (rename/rename): "1628"Rename\"%s\"->\"%s\"in branch\"%s\""1629"rename\"%s\"->\"%s\"in\"%s\"%s"),1630 one->path, a->path, ci->branch1,1631 one->path, b->path, ci->branch2,1632 o->call_depth ?_(" (left unresolved)") :"");1633if(o->call_depth) {1634struct merge_file_info mfi;1635struct diff_filespec other;1636struct diff_filespec *add;1637if(merge_file_one(o, one->path,1638&one->oid, one->mode,1639&a->oid, a->mode,1640&b->oid, b->mode,1641 ci->branch1, ci->branch2, &mfi))1642return-1;16431644/*1645 * FIXME: For rename/add-source conflicts (if we could detect1646 * such), this is wrong. We should instead find a unique1647 * pathname and then either rename the add-source file to that1648 * unique path, or use that unique path instead of src here.1649 */1650if(update_file(o,0, &mfi.oid, mfi.mode, one->path))1651return-1;16521653/*1654 * Above, we put the merged content at the merge-base's1655 * path. Now we usually need to delete both a->path and1656 * b->path. However, the rename on each side of the merge1657 * could also be involved in a rename/add conflict. In1658 * such cases, we should keep the added file around,1659 * resolving the conflict at that path in its favor.1660 */1661 add =filespec_from_entry(&other, ci->dst_entry1,2^1);1662if(add) {1663if(update_file(o,0, &add->oid, add->mode, a->path))1664return-1;1665}1666else1667remove_file_from_cache(a->path);1668 add =filespec_from_entry(&other, ci->dst_entry2,3^1);1669if(add) {1670if(update_file(o,0, &add->oid, add->mode, b->path))1671return-1;1672}1673else1674remove_file_from_cache(b->path);1675}else if(handle_file(o, a,2, ci) ||handle_file(o, b,3, ci))1676return-1;16771678return0;1679}16801681static intconflict_rename_rename_2to1(struct merge_options *o,1682struct rename_conflict_info *ci)1683{1684/* Two files, a & b, were renamed to the same thing, c. */1685struct diff_filespec *a = ci->pair1->one;1686struct diff_filespec *b = ci->pair2->one;1687struct diff_filespec *c1 = ci->pair1->two;1688struct diff_filespec *c2 = ci->pair2->two;1689char*path = c1->path;/* == c2->path */1690char*path_side_1_desc;1691char*path_side_2_desc;1692struct merge_file_info mfi_c1;1693struct merge_file_info mfi_c2;1694int ret;16951696output(o,1,_("CONFLICT (rename/rename): "1697"Rename%s->%sin%s. "1698"Rename%s->%sin%s"),1699 a->path, c1->path, ci->branch1,1700 b->path, c2->path, ci->branch2);17011702remove_file(o,1, a->path, o->call_depth ||would_lose_untracked(a->path));1703remove_file(o,1, b->path, o->call_depth ||would_lose_untracked(b->path));17041705 path_side_1_desc =xstrfmt("%s(was%s)", path, a->path);1706 path_side_2_desc =xstrfmt("%s(was%s)", path, b->path);1707if(merge_file_special_markers(o, a, c1, &ci->ren1_other,1708 path_side_1_desc,1709 o->branch1, c1->path,1710 o->branch2, ci->ren1_other.path, &mfi_c1) ||1711merge_file_special_markers(o, b, &ci->ren2_other, c2,1712 path_side_2_desc,1713 o->branch1, ci->ren2_other.path,1714 o->branch2, c2->path, &mfi_c2))1715return-1;1716free(path_side_1_desc);1717free(path_side_2_desc);17181719if(o->call_depth) {1720/*1721 * If mfi_c1.clean && mfi_c2.clean, then it might make1722 * sense to do a two-way merge of those results. But, I1723 * think in all cases, it makes sense to have the virtual1724 * merge base just undo the renames; they can be detected1725 * again later for the non-recursive merge.1726 */1727remove_file(o,0, path,0);1728 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, a->path);1729if(!ret)1730 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1731 b->path);1732}else{1733char*new_path1 =unique_path(o, path, ci->branch1);1734char*new_path2 =unique_path(o, path, ci->branch2);1735output(o,1,_("Renaming%sto%sand%sto%sinstead"),1736 a->path, new_path1, b->path, new_path2);1737if(was_dirty(o, path))1738output(o,1,_("Refusing to lose dirty file at%s"),1739 path);1740else if(would_lose_untracked(path))1741/*1742 * Only way we get here is if both renames were from1743 * a directory rename AND user had an untracked file1744 * at the location where both files end up after the1745 * two directory renames. See testcase 10d of t6043.1746 */1747output(o,1,_("Refusing to lose untracked file at "1748"%s, even though it's in the way."),1749 path);1750else1751remove_file(o,0, path,0);1752 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, new_path1);1753if(!ret)1754 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1755 new_path2);1756/*1757 * unpack_trees() actually populates the index for us for1758 * "normal" rename/rename(2to1) situtations so that the1759 * correct entries are at the higher stages, which would1760 * make the call below to update_stages_for_stage_data1761 * unnecessary. However, if either of the renames came1762 * from a directory rename, then unpack_trees() will not1763 * have gotten the right data loaded into the index, so we1764 * need to do so now. (While it'd be tempting to move this1765 * call to update_stages_for_stage_data() to1766 * apply_directory_rename_modifications(), that would break1767 * our intermediate calls to would_lose_untracked() since1768 * those rely on the current in-memory index. See also the1769 * big "NOTE" in update_stages()).1770 */1771if(update_stages_for_stage_data(o, path, ci->dst_entry1))1772 ret = -1;17731774free(new_path2);1775free(new_path1);1776}17771778return ret;1779}17801781/*1782 * Get the diff_filepairs changed between o_tree and tree.1783 */1784static struct diff_queue_struct *get_diffpairs(struct merge_options *o,1785struct tree *o_tree,1786struct tree *tree)1787{1788struct diff_queue_struct *ret;1789struct diff_options opts;17901791diff_setup(&opts);1792 opts.flags.recursive =1;1793 opts.flags.rename_empty =0;1794 opts.detect_rename =merge_detect_rename(o);1795/*1796 * We do not have logic to handle the detection of copies. In1797 * fact, it may not even make sense to add such logic: would we1798 * really want a change to a base file to be propagated through1799 * multiple other files by a merge?1800 */1801if(opts.detect_rename > DIFF_DETECT_RENAME)1802 opts.detect_rename = DIFF_DETECT_RENAME;1803 opts.rename_limit = o->merge_rename_limit >=0? o->merge_rename_limit :1804 o->diff_rename_limit >=0? o->diff_rename_limit :18051000;1806 opts.rename_score = o->rename_score;1807 opts.show_rename_progress = o->show_rename_progress;1808 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1809diff_setup_done(&opts);1810diff_tree_oid(&o_tree->object.oid, &tree->object.oid,"", &opts);1811diffcore_std(&opts);1812if(opts.needed_rename_limit > o->needed_rename_limit)1813 o->needed_rename_limit = opts.needed_rename_limit;18141815 ret =xmalloc(sizeof(*ret));1816*ret = diff_queued_diff;18171818 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1819 diff_queued_diff.nr =0;1820 diff_queued_diff.queue = NULL;1821diff_flush(&opts);1822return ret;1823}18241825static inttree_has_path(struct tree *tree,const char*path)1826{1827struct object_id hashy;1828unsigned int mode_o;18291830return!get_tree_entry(&tree->object.oid, path,1831&hashy, &mode_o);1832}18331834/*1835 * Return a new string that replaces the beginning portion (which matches1836 * entry->dir), with entry->new_dir. In perl-speak:1837 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1838 * NOTE:1839 * Caller must ensure that old_path starts with entry->dir + '/'.1840 */1841static char*apply_dir_rename(struct dir_rename_entry *entry,1842const char*old_path)1843{1844struct strbuf new_path = STRBUF_INIT;1845int oldlen, newlen;18461847if(entry->non_unique_new_dir)1848return NULL;18491850 oldlen =strlen(entry->dir);1851 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) +1;1852strbuf_grow(&new_path, newlen);1853strbuf_addbuf(&new_path, &entry->new_dir);1854strbuf_addstr(&new_path, &old_path[oldlen]);18551856returnstrbuf_detach(&new_path, NULL);1857}18581859static voidget_renamed_dir_portion(const char*old_path,const char*new_path,1860char**old_dir,char**new_dir)1861{1862char*end_of_old, *end_of_new;1863int old_len, new_len;18641865*old_dir = NULL;1866*new_dir = NULL;18671868/*1869 * For1870 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1871 * the "e/foo.c" part is the same, we just want to know that1872 * "a/b/c/d" was renamed to "a/b/some/thing/else"1873 * so, for this example, this function returns "a/b/c/d" in1874 * *old_dir and "a/b/some/thing/else" in *new_dir.1875 *1876 * Also, if the basename of the file changed, we don't care. We1877 * want to know which portion of the directory, if any, changed.1878 */1879 end_of_old =strrchr(old_path,'/');1880 end_of_new =strrchr(new_path,'/');18811882if(end_of_old == NULL || end_of_new == NULL)1883return;1884while(*--end_of_new == *--end_of_old &&1885 end_of_old != old_path &&1886 end_of_new != new_path)1887;/* Do nothing; all in the while loop */1888/*1889 * We've found the first non-matching character in the directory1890 * paths. That means the current directory we were comparing1891 * represents the rename. Move end_of_old and end_of_new back1892 * to the full directory name.1893 */1894if(*end_of_old =='/')1895 end_of_old++;1896if(*end_of_old !='/')1897 end_of_new++;1898 end_of_old =strchr(end_of_old,'/');1899 end_of_new =strchr(end_of_new,'/');19001901/*1902 * It may have been the case that old_path and new_path were the same1903 * directory all along. Don't claim a rename if they're the same.1904 */1905 old_len = end_of_old - old_path;1906 new_len = end_of_new - new_path;19071908if(old_len != new_len ||strncmp(old_path, new_path, old_len)) {1909*old_dir =xstrndup(old_path, old_len);1910*new_dir =xstrndup(new_path, new_len);1911}1912}19131914static voidremove_hashmap_entries(struct hashmap *dir_renames,1915struct string_list *items_to_remove)1916{1917int i;1918struct dir_rename_entry *entry;19191920for(i =0; i < items_to_remove->nr; i++) {1921 entry = items_to_remove->items[i].util;1922hashmap_remove(dir_renames, entry, NULL);1923}1924string_list_clear(items_to_remove,0);1925}19261927/*1928 * See if there is a directory rename for path, and if there are any file1929 * level conflicts for the renamed location. If there is a rename and1930 * there are no conflicts, return the new name. Otherwise, return NULL.1931 */1932static char*handle_path_level_conflicts(struct merge_options *o,1933const char*path,1934struct dir_rename_entry *entry,1935struct hashmap *collisions,1936struct tree *tree)1937{1938char*new_path = NULL;1939struct collision_entry *collision_ent;1940int clean =1;1941struct strbuf collision_paths = STRBUF_INIT;19421943/*1944 * entry has the mapping of old directory name to new directory name1945 * that we want to apply to path.1946 */1947 new_path =apply_dir_rename(entry, path);19481949if(!new_path) {1950/* This should only happen when entry->non_unique_new_dir set */1951if(!entry->non_unique_new_dir)1952BUG("entry->non_unqiue_dir not set and !new_path");1953output(o,1,_("CONFLICT (directory rename split): "1954"Unclear where to place%sbecause directory "1955"%swas renamed to multiple other directories, "1956"with no destination getting a majority of the "1957"files."),1958 path, entry->dir);1959 clean =0;1960return NULL;1961}19621963/*1964 * The caller needs to have ensured that it has pre-populated1965 * collisions with all paths that map to new_path. Do a quick check1966 * to ensure that's the case.1967 */1968 collision_ent =collision_find_entry(collisions, new_path);1969if(collision_ent == NULL)1970BUG("collision_ent is NULL");19711972/*1973 * Check for one-sided add/add/.../add conflicts, i.e.1974 * where implicit renames from the other side doing1975 * directory rename(s) can affect this side of history1976 * to put multiple paths into the same location. Warn1977 * and bail on directory renames for such paths.1978 */1979if(collision_ent->reported_already) {1980 clean =0;1981}else if(tree_has_path(tree, new_path)) {1982 collision_ent->reported_already =1;1983strbuf_add_separated_string_list(&collision_paths,", ",1984&collision_ent->source_files);1985output(o,1,_("CONFLICT (implicit dir rename): Existing "1986"file/dir at%sin the way of implicit "1987"directory rename(s) putting the following "1988"path(s) there:%s."),1989 new_path, collision_paths.buf);1990 clean =0;1991}else if(collision_ent->source_files.nr >1) {1992 collision_ent->reported_already =1;1993strbuf_add_separated_string_list(&collision_paths,", ",1994&collision_ent->source_files);1995output(o,1,_("CONFLICT (implicit dir rename): Cannot map "1996"more than one path to%s; implicit directory "1997"renames tried to put these paths there:%s"),1998 new_path, collision_paths.buf);1999 clean =0;2000}20012002/* Free memory we no longer need */2003strbuf_release(&collision_paths);2004if(!clean && new_path) {2005free(new_path);2006return NULL;2007}20082009return new_path;2010}20112012/*2013 * There are a couple things we want to do at the directory level:2014 * 1. Check for both sides renaming to the same thing, in order to avoid2015 * implicit renaming of files that should be left in place. (See2016 * testcase 6b in t6043 for details.)2017 * 2. Prune directory renames if there are still files left in the2018 * the original directory. These represent a partial directory rename,2019 * i.e. a rename where only some of the files within the directory2020 * were renamed elsewhere. (Technically, this could be done earlier2021 * in get_directory_renames(), except that would prevent us from2022 * doing the previous check and thus failing testcase 6b.)2023 * 3. Check for rename/rename(1to2) conflicts (at the directory level).2024 * In the future, we could potentially record this info as well and2025 * omit reporting rename/rename(1to2) conflicts for each path within2026 * the affected directories, thus cleaning up the merge output.2027 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the2028 * directory level, because merging directories is fine. If it2029 * causes conflicts for files within those merged directories, then2030 * that should be detected at the individual path level.2031 */2032static voidhandle_directory_level_conflicts(struct merge_options *o,2033struct hashmap *dir_re_head,2034struct tree *head,2035struct hashmap *dir_re_merge,2036struct tree *merge)2037{2038struct hashmap_iter iter;2039struct dir_rename_entry *head_ent;2040struct dir_rename_entry *merge_ent;20412042struct string_list remove_from_head = STRING_LIST_INIT_NODUP;2043struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;20442045hashmap_iter_init(dir_re_head, &iter);2046while((head_ent =hashmap_iter_next(&iter))) {2047 merge_ent =dir_rename_find_entry(dir_re_merge, head_ent->dir);2048if(merge_ent &&2049!head_ent->non_unique_new_dir &&2050!merge_ent->non_unique_new_dir &&2051!strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {2052/* 1. Renamed identically; remove it from both sides */2053string_list_append(&remove_from_head,2054 head_ent->dir)->util = head_ent;2055strbuf_release(&head_ent->new_dir);2056string_list_append(&remove_from_merge,2057 merge_ent->dir)->util = merge_ent;2058strbuf_release(&merge_ent->new_dir);2059}else if(tree_has_path(head, head_ent->dir)) {2060/* 2. This wasn't a directory rename after all */2061string_list_append(&remove_from_head,2062 head_ent->dir)->util = head_ent;2063strbuf_release(&head_ent->new_dir);2064}2065}20662067remove_hashmap_entries(dir_re_head, &remove_from_head);2068remove_hashmap_entries(dir_re_merge, &remove_from_merge);20692070hashmap_iter_init(dir_re_merge, &iter);2071while((merge_ent =hashmap_iter_next(&iter))) {2072 head_ent =dir_rename_find_entry(dir_re_head, merge_ent->dir);2073if(tree_has_path(merge, merge_ent->dir)) {2074/* 2. This wasn't a directory rename after all */2075string_list_append(&remove_from_merge,2076 merge_ent->dir)->util = merge_ent;2077}else if(head_ent &&2078!head_ent->non_unique_new_dir &&2079!merge_ent->non_unique_new_dir) {2080/* 3. rename/rename(1to2) */2081/*2082 * We can assume it's not rename/rename(1to1) because2083 * that was case (1), already checked above. So we2084 * know that head_ent->new_dir and merge_ent->new_dir2085 * are different strings.2086 */2087output(o,1,_("CONFLICT (rename/rename): "2088"Rename directory%s->%sin%s. "2089"Rename directory%s->%sin%s"),2090 head_ent->dir, head_ent->new_dir.buf, o->branch1,2091 head_ent->dir, merge_ent->new_dir.buf, o->branch2);2092string_list_append(&remove_from_head,2093 head_ent->dir)->util = head_ent;2094strbuf_release(&head_ent->new_dir);2095string_list_append(&remove_from_merge,2096 merge_ent->dir)->util = merge_ent;2097strbuf_release(&merge_ent->new_dir);2098}2099}21002101remove_hashmap_entries(dir_re_head, &remove_from_head);2102remove_hashmap_entries(dir_re_merge, &remove_from_merge);2103}21042105static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,2106struct tree *tree)2107{2108struct hashmap *dir_renames;2109struct hashmap_iter iter;2110struct dir_rename_entry *entry;2111int i;21122113/*2114 * Typically, we think of a directory rename as all files from a2115 * certain directory being moved to a target directory. However,2116 * what if someone first moved two files from the original2117 * directory in one commit, and then renamed the directory2118 * somewhere else in a later commit? At merge time, we just know2119 * that files from the original directory went to two different2120 * places, and that the bulk of them ended up in the same place.2121 * We want each directory rename to represent where the bulk of the2122 * files from that directory end up; this function exists to find2123 * where the bulk of the files went.2124 *2125 * The first loop below simply iterates through the list of file2126 * renames, finding out how often each directory rename pair2127 * possibility occurs.2128 */2129 dir_renames =xmalloc(sizeof(*dir_renames));2130dir_rename_init(dir_renames);2131for(i =0; i < pairs->nr; ++i) {2132struct string_list_item *item;2133int*count;2134struct diff_filepair *pair = pairs->queue[i];2135char*old_dir, *new_dir;21362137/* File not part of directory rename if it wasn't renamed */2138if(pair->status !='R')2139continue;21402141get_renamed_dir_portion(pair->one->path, pair->two->path,2142&old_dir, &new_dir);2143if(!old_dir)2144/* Directory didn't change at all; ignore this one. */2145continue;21462147 entry =dir_rename_find_entry(dir_renames, old_dir);2148if(!entry) {2149 entry =xmalloc(sizeof(*entry));2150dir_rename_entry_init(entry, old_dir);2151hashmap_put(dir_renames, entry);2152}else{2153free(old_dir);2154}2155 item =string_list_lookup(&entry->possible_new_dirs, new_dir);2156if(!item) {2157 item =string_list_insert(&entry->possible_new_dirs,2158 new_dir);2159 item->util =xcalloc(1,sizeof(int));2160}else{2161free(new_dir);2162}2163 count = item->util;2164*count +=1;2165}21662167/*2168 * For each directory with files moved out of it, we find out which2169 * target directory received the most files so we can declare it to2170 * be the "winning" target location for the directory rename. This2171 * winner gets recorded in new_dir. If there is no winner2172 * (multiple target directories received the same number of files),2173 * we set non_unique_new_dir. Once we've determined the winner (or2174 * that there is no winner), we no longer need possible_new_dirs.2175 */2176hashmap_iter_init(dir_renames, &iter);2177while((entry =hashmap_iter_next(&iter))) {2178int max =0;2179int bad_max =0;2180char*best = NULL;21812182for(i =0; i < entry->possible_new_dirs.nr; i++) {2183int*count = entry->possible_new_dirs.items[i].util;21842185if(*count == max)2186 bad_max = max;2187else if(*count > max) {2188 max = *count;2189 best = entry->possible_new_dirs.items[i].string;2190}2191}2192if(bad_max == max)2193 entry->non_unique_new_dir =1;2194else{2195assert(entry->new_dir.len ==0);2196strbuf_addstr(&entry->new_dir, best);2197}2198/*2199 * The relevant directory sub-portion of the original full2200 * filepaths were xstrndup'ed before inserting into2201 * possible_new_dirs, and instead of manually iterating the2202 * list and free'ing each, just lie and tell2203 * possible_new_dirs that it did the strdup'ing so that it2204 * will free them for us.2205 */2206 entry->possible_new_dirs.strdup_strings =1;2207string_list_clear(&entry->possible_new_dirs,1);2208}22092210return dir_renames;2211}22122213static struct dir_rename_entry *check_dir_renamed(const char*path,2214struct hashmap *dir_renames)2215{2216char*temp =xstrdup(path);2217char*end;2218struct dir_rename_entry *entry = NULL;;22192220while((end =strrchr(temp,'/'))) {2221*end ='\0';2222 entry =dir_rename_find_entry(dir_renames, temp);2223if(entry)2224break;2225}2226free(temp);2227return entry;2228}22292230static voidcompute_collisions(struct hashmap *collisions,2231struct hashmap *dir_renames,2232struct diff_queue_struct *pairs)2233{2234int i;22352236/*2237 * Multiple files can be mapped to the same path due to directory2238 * renames done by the other side of history. Since that other2239 * side of history could have merged multiple directories into one,2240 * if our side of history added the same file basename to each of2241 * those directories, then all N of them would get implicitly2242 * renamed by the directory rename detection into the same path,2243 * and we'd get an add/add/.../add conflict, and all those adds2244 * from *this* side of history. This is not representable in the2245 * index, and users aren't going to easily be able to make sense of2246 * it. So we need to provide a good warning about what's2247 * happening, and fall back to no-directory-rename detection2248 * behavior for those paths.2249 *2250 * See testcases 9e and all of section 5 from t6043 for examples.2251 */2252collision_init(collisions);22532254for(i =0; i < pairs->nr; ++i) {2255struct dir_rename_entry *dir_rename_ent;2256struct collision_entry *collision_ent;2257char*new_path;2258struct diff_filepair *pair = pairs->queue[i];22592260if(pair->status !='A'&& pair->status !='R')2261continue;2262 dir_rename_ent =check_dir_renamed(pair->two->path,2263 dir_renames);2264if(!dir_rename_ent)2265continue;22662267 new_path =apply_dir_rename(dir_rename_ent, pair->two->path);2268if(!new_path)2269/*2270 * dir_rename_ent->non_unique_new_path is true, which2271 * means there is no directory rename for us to use,2272 * which means it won't cause us any additional2273 * collisions.2274 */2275continue;2276 collision_ent =collision_find_entry(collisions, new_path);2277if(!collision_ent) {2278 collision_ent =xcalloc(1,2279sizeof(struct collision_entry));2280hashmap_entry_init(collision_ent,strhash(new_path));2281hashmap_put(collisions, collision_ent);2282 collision_ent->target_file = new_path;2283}else{2284free(new_path);2285}2286string_list_insert(&collision_ent->source_files,2287 pair->two->path);2288}2289}22902291static char*check_for_directory_rename(struct merge_options *o,2292const char*path,2293struct tree *tree,2294struct hashmap *dir_renames,2295struct hashmap *dir_rename_exclusions,2296struct hashmap *collisions,2297int*clean_merge)2298{2299char*new_path = NULL;2300struct dir_rename_entry *entry =check_dir_renamed(path, dir_renames);2301struct dir_rename_entry *oentry = NULL;23022303if(!entry)2304return new_path;23052306/*2307 * This next part is a little weird. We do not want to do an2308 * implicit rename into a directory we renamed on our side, because2309 * that will result in a spurious rename/rename(1to2) conflict. An2310 * example:2311 * Base commit: dumbdir/afile, otherdir/bfile2312 * Side 1: smrtdir/afile, otherdir/bfile2313 * Side 2: dumbdir/afile, dumbdir/bfile2314 * Here, while working on Side 1, we could notice that otherdir was2315 * renamed/merged to dumbdir, and change the diff_filepair for2316 * otherdir/bfile into a rename into dumbdir/bfile. However, Side2317 * 2 will notice the rename from dumbdir to smrtdir, and do the2318 * transitive rename to move it from dumbdir/bfile to2319 * smrtdir/bfile. That gives us bfile in dumbdir vs being in2320 * smrtdir, a rename/rename(1to2) conflict. We really just want2321 * the file to end up in smrtdir. And the way to achieve that is2322 * to not let Side1 do the rename to dumbdir, since we know that is2323 * the source of one of our directory renames.2324 *2325 * That's why oentry and dir_rename_exclusions is here.2326 *2327 * As it turns out, this also prevents N-way transient rename2328 * confusion; See testcases 9c and 9d of t6043.2329 */2330 oentry =dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);2331if(oentry) {2332output(o,1,_("WARNING: Avoiding applying%s->%srename "2333"to%s, because%sitself was renamed."),2334 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);2335}else{2336 new_path =handle_path_level_conflicts(o, path, entry,2337 collisions, tree);2338*clean_merge &= (new_path != NULL);2339}23402341return new_path;2342}23432344static voidapply_directory_rename_modifications(struct merge_options *o,2345struct diff_filepair *pair,2346char*new_path,2347struct rename *re,2348struct tree *tree,2349struct tree *o_tree,2350struct tree *a_tree,2351struct tree *b_tree,2352struct string_list *entries,2353int*clean)2354{2355struct string_list_item *item;2356int stage = (tree == a_tree ?2:3);2357int update_wd;23582359/*2360 * In all cases where we can do directory rename detection,2361 * unpack_trees() will have read pair->two->path into the2362 * index and the working copy. We need to remove it so that2363 * we can instead place it at new_path. It is guaranteed to2364 * not be untracked (unpack_trees() would have errored out2365 * saying the file would have been overwritten), but it might2366 * be dirty, though.2367 */2368 update_wd = !was_dirty(o, pair->two->path);2369if(!update_wd)2370output(o,1,_("Refusing to lose dirty file at%s"),2371 pair->two->path);2372remove_file(o,1, pair->two->path, !update_wd);23732374/* Find or create a new re->dst_entry */2375 item =string_list_lookup(entries, new_path);2376if(item) {2377/*2378 * Since we're renaming on this side of history, and it's2379 * due to a directory rename on the other side of history2380 * (which we only allow when the directory in question no2381 * longer exists on the other side of history), the2382 * original entry for re->dst_entry is no longer2383 * necessary...2384 */2385 re->dst_entry->processed =1;23862387/*2388 * ...because we'll be using this new one.2389 */2390 re->dst_entry = item->util;2391}else{2392/*2393 * re->dst_entry is for the before-dir-rename path, and we2394 * need it to hold information for the after-dir-rename2395 * path. Before creating a new entry, we need to mark the2396 * old one as unnecessary (...unless it is shared by2397 * src_entry, i.e. this didn't use to be a rename, in which2398 * case we can just allow the normal processing to happen2399 * for it).2400 */2401if(pair->status =='R')2402 re->dst_entry->processed =1;24032404 re->dst_entry =insert_stage_data(new_path,2405 o_tree, a_tree, b_tree,2406 entries);2407 item =string_list_insert(entries, new_path);2408 item->util = re->dst_entry;2409}24102411/*2412 * Update the stage_data with the information about the path we are2413 * moving into place. That slot will be empty and available for us2414 * to write to because of the collision checks in2415 * handle_path_level_conflicts(). In other words,2416 * re->dst_entry->stages[stage].oid will be the null_oid, so it's2417 * open for us to write to.2418 *2419 * It may be tempting to actually update the index at this point as2420 * well, using update_stages_for_stage_data(), but as per the big2421 * "NOTE" in update_stages(), doing so will modify the current2422 * in-memory index which will break calls to would_lose_untracked()2423 * that we need to make. Instead, we need to just make sure that2424 * the various conflict_rename_*() functions update the index2425 * explicitly rather than relying on unpack_trees() to have done it.2426 */2427get_tree_entry(&tree->object.oid,2428 pair->two->path,2429&re->dst_entry->stages[stage].oid,2430&re->dst_entry->stages[stage].mode);24312432/* Update pair status */2433if(pair->status =='A') {2434/*2435 * Recording rename information for this add makes it look2436 * like a rename/delete conflict. Make sure we can2437 * correctly handle this as an add that was moved to a new2438 * directory instead of reporting a rename/delete conflict.2439 */2440 re->add_turned_into_rename =1;2441}2442/*2443 * We don't actually look at pair->status again, but it seems2444 * pedagogically correct to adjust it.2445 */2446 pair->status ='R';24472448/*2449 * Finally, record the new location.2450 */2451 pair->two->path = new_path;2452}24532454/*2455 * Get information of all renames which occurred in 'pairs', making use of2456 * any implicit directory renames inferred from the other side of history.2457 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')2458 * to be able to associate the correct cache entries with the rename2459 * information; tree is always equal to either a_tree or b_tree.2460 */2461static struct string_list *get_renames(struct merge_options *o,2462struct diff_queue_struct *pairs,2463struct hashmap *dir_renames,2464struct hashmap *dir_rename_exclusions,2465struct tree *tree,2466struct tree *o_tree,2467struct tree *a_tree,2468struct tree *b_tree,2469struct string_list *entries,2470int*clean_merge)2471{2472int i;2473struct hashmap collisions;2474struct hashmap_iter iter;2475struct collision_entry *e;2476struct string_list *renames;24772478compute_collisions(&collisions, dir_renames, pairs);2479 renames =xcalloc(1,sizeof(struct string_list));24802481for(i =0; i < pairs->nr; ++i) {2482struct string_list_item *item;2483struct rename *re;2484struct diff_filepair *pair = pairs->queue[i];2485char*new_path;/* non-NULL only with directory renames */24862487if(pair->status !='A'&& pair->status !='R') {2488diff_free_filepair(pair);2489continue;2490}2491 new_path =check_for_directory_rename(o, pair->two->path, tree,2492 dir_renames,2493 dir_rename_exclusions,2494&collisions,2495 clean_merge);2496if(pair->status !='R'&& !new_path) {2497diff_free_filepair(pair);2498continue;2499}25002501 re =xmalloc(sizeof(*re));2502 re->processed =0;2503 re->add_turned_into_rename =0;2504 re->pair = pair;2505 item =string_list_lookup(entries, re->pair->one->path);2506if(!item)2507 re->src_entry =insert_stage_data(re->pair->one->path,2508 o_tree, a_tree, b_tree, entries);2509else2510 re->src_entry = item->util;25112512 item =string_list_lookup(entries, re->pair->two->path);2513if(!item)2514 re->dst_entry =insert_stage_data(re->pair->two->path,2515 o_tree, a_tree, b_tree, entries);2516else2517 re->dst_entry = item->util;2518 item =string_list_insert(renames, pair->one->path);2519 item->util = re;2520if(new_path)2521apply_directory_rename_modifications(o, pair, new_path,2522 re, tree, o_tree,2523 a_tree, b_tree,2524 entries,2525 clean_merge);2526}25272528hashmap_iter_init(&collisions, &iter);2529while((e =hashmap_iter_next(&iter))) {2530free(e->target_file);2531string_list_clear(&e->source_files,0);2532}2533hashmap_free(&collisions,1);2534return renames;2535}25362537static intprocess_renames(struct merge_options *o,2538struct string_list *a_renames,2539struct string_list *b_renames)2540{2541int clean_merge =1, i, j;2542struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2543struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2544const struct rename *sre;25452546for(i =0; i < a_renames->nr; i++) {2547 sre = a_renames->items[i].util;2548string_list_insert(&a_by_dst, sre->pair->two->path)->util2549= (void*)sre;2550}2551for(i =0; i < b_renames->nr; i++) {2552 sre = b_renames->items[i].util;2553string_list_insert(&b_by_dst, sre->pair->two->path)->util2554= (void*)sre;2555}25562557for(i =0, j =0; i < a_renames->nr || j < b_renames->nr;) {2558struct string_list *renames1, *renames2Dst;2559struct rename *ren1 = NULL, *ren2 = NULL;2560const char*branch1, *branch2;2561const char*ren1_src, *ren1_dst;2562struct string_list_item *lookup;25632564if(i >= a_renames->nr) {2565 ren2 = b_renames->items[j++].util;2566}else if(j >= b_renames->nr) {2567 ren1 = a_renames->items[i++].util;2568}else{2569int compare =strcmp(a_renames->items[i].string,2570 b_renames->items[j].string);2571if(compare <=0)2572 ren1 = a_renames->items[i++].util;2573if(compare >=0)2574 ren2 = b_renames->items[j++].util;2575}25762577/* TODO: refactor, so that 1/2 are not needed */2578if(ren1) {2579 renames1 = a_renames;2580 renames2Dst = &b_by_dst;2581 branch1 = o->branch1;2582 branch2 = o->branch2;2583}else{2584 renames1 = b_renames;2585 renames2Dst = &a_by_dst;2586 branch1 = o->branch2;2587 branch2 = o->branch1;2588SWAP(ren2, ren1);2589}25902591if(ren1->processed)2592continue;2593 ren1->processed =1;2594 ren1->dst_entry->processed =1;2595/* BUG: We should only mark src_entry as processed if we2596 * are not dealing with a rename + add-source case.2597 */2598 ren1->src_entry->processed =1;25992600 ren1_src = ren1->pair->one->path;2601 ren1_dst = ren1->pair->two->path;26022603if(ren2) {2604/* One file renamed on both sides */2605const char*ren2_src = ren2->pair->one->path;2606const char*ren2_dst = ren2->pair->two->path;2607enum rename_type rename_type;2608if(strcmp(ren1_src, ren2_src) !=0)2609BUG("ren1_src != ren2_src");2610 ren2->dst_entry->processed =1;2611 ren2->processed =1;2612if(strcmp(ren1_dst, ren2_dst) !=0) {2613 rename_type = RENAME_ONE_FILE_TO_TWO;2614 clean_merge =0;2615}else{2616 rename_type = RENAME_ONE_FILE_TO_ONE;2617/* BUG: We should only remove ren1_src in2618 * the base stage (think of rename +2619 * add-source cases).2620 */2621remove_file(o,1, ren1_src,1);2622update_entry(ren1->dst_entry,2623 ren1->pair->one,2624 ren1->pair->two,2625 ren2->pair->two);2626}2627setup_rename_conflict_info(rename_type,2628 ren1->pair,2629 ren2->pair,2630 branch1,2631 branch2,2632 ren1->dst_entry,2633 ren2->dst_entry,2634 o,2635 NULL,2636 NULL);2637}else if((lookup =string_list_lookup(renames2Dst, ren1_dst))) {2638/* Two different files renamed to the same thing */2639char*ren2_dst;2640 ren2 = lookup->util;2641 ren2_dst = ren2->pair->two->path;2642if(strcmp(ren1_dst, ren2_dst) !=0)2643BUG("ren1_dst != ren2_dst");26442645 clean_merge =0;2646 ren2->processed =1;2647/*2648 * BUG: We should only mark src_entry as processed2649 * if we are not dealing with a rename + add-source2650 * case.2651 */2652 ren2->src_entry->processed =1;26532654setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2655 ren1->pair,2656 ren2->pair,2657 branch1,2658 branch2,2659 ren1->dst_entry,2660 ren2->dst_entry,2661 o,2662 ren1->src_entry,2663 ren2->src_entry);26642665}else{2666/* Renamed in 1, maybe changed in 2 */2667/* we only use sha1 and mode of these */2668struct diff_filespec src_other, dst_other;2669int try_merge;26702671/*2672 * unpack_trees loads entries from common-commit2673 * into stage 1, from head-commit into stage 2, and2674 * from merge-commit into stage 3. We keep track2675 * of which side corresponds to the rename.2676 */2677int renamed_stage = a_renames == renames1 ?2:3;2678int other_stage = a_renames == renames1 ?3:2;26792680/* BUG: We should only remove ren1_src in the base2681 * stage and in other_stage (think of rename +2682 * add-source case).2683 */2684remove_file(o,1, ren1_src,2685 renamed_stage ==2|| !was_tracked(o, ren1_src));26862687oidcpy(&src_other.oid,2688&ren1->src_entry->stages[other_stage].oid);2689 src_other.mode = ren1->src_entry->stages[other_stage].mode;2690oidcpy(&dst_other.oid,2691&ren1->dst_entry->stages[other_stage].oid);2692 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2693 try_merge =0;26942695if(oid_eq(&src_other.oid, &null_oid) &&2696 ren1->add_turned_into_rename) {2697setup_rename_conflict_info(RENAME_DIR,2698 ren1->pair,2699 NULL,2700 branch1,2701 branch2,2702 ren1->dst_entry,2703 NULL,2704 o,2705 NULL,2706 NULL);2707}else if(oid_eq(&src_other.oid, &null_oid)) {2708setup_rename_conflict_info(RENAME_DELETE,2709 ren1->pair,2710 NULL,2711 branch1,2712 branch2,2713 ren1->dst_entry,2714 NULL,2715 o,2716 NULL,2717 NULL);2718}else if((dst_other.mode == ren1->pair->two->mode) &&2719oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2720/*2721 * Added file on the other side identical to2722 * the file being renamed: clean merge.2723 * Also, there is no need to overwrite the2724 * file already in the working copy, so call2725 * update_file_flags() instead of2726 * update_file().2727 */2728if(update_file_flags(o,2729&ren1->pair->two->oid,2730 ren1->pair->two->mode,2731 ren1_dst,27321,/* update_cache */27330/* update_wd */))2734 clean_merge = -1;2735}else if(!oid_eq(&dst_other.oid, &null_oid)) {2736 clean_merge =0;2737 try_merge =1;2738output(o,1,_("CONFLICT (rename/add): Rename%s->%sin%s. "2739"%sadded in%s"),2740 ren1_src, ren1_dst, branch1,2741 ren1_dst, branch2);2742if(o->call_depth) {2743struct merge_file_info mfi;2744if(merge_file_one(o, ren1_dst, &null_oid,0,2745&ren1->pair->two->oid,2746 ren1->pair->two->mode,2747&dst_other.oid,2748 dst_other.mode,2749 branch1, branch2, &mfi)) {2750 clean_merge = -1;2751goto cleanup_and_return;2752}2753output(o,1,_("Adding merged%s"), ren1_dst);2754if(update_file(o,0, &mfi.oid,2755 mfi.mode, ren1_dst))2756 clean_merge = -1;2757 try_merge =0;2758}else{2759char*new_path =unique_path(o, ren1_dst, branch2);2760output(o,1,_("Adding as%sinstead"), new_path);2761if(update_file(o,0, &dst_other.oid,2762 dst_other.mode, new_path))2763 clean_merge = -1;2764free(new_path);2765}2766}else2767 try_merge =1;27682769if(clean_merge <0)2770goto cleanup_and_return;2771if(try_merge) {2772struct diff_filespec *one, *a, *b;2773 src_other.path = (char*)ren1_src;27742775 one = ren1->pair->one;2776if(a_renames == renames1) {2777 a = ren1->pair->two;2778 b = &src_other;2779}else{2780 b = ren1->pair->two;2781 a = &src_other;2782}2783update_entry(ren1->dst_entry, one, a, b);2784setup_rename_conflict_info(RENAME_NORMAL,2785 ren1->pair,2786 NULL,2787 branch1,2788 NULL,2789 ren1->dst_entry,2790 NULL,2791 o,2792 NULL,2793 NULL);2794}2795}2796}2797cleanup_and_return:2798string_list_clear(&a_by_dst,0);2799string_list_clear(&b_by_dst,0);28002801return clean_merge;2802}28032804struct rename_info {2805struct string_list *head_renames;2806struct string_list *merge_renames;2807};28082809static voidinitial_cleanup_rename(struct diff_queue_struct *pairs,2810struct hashmap *dir_renames)2811{2812struct hashmap_iter iter;2813struct dir_rename_entry *e;28142815hashmap_iter_init(dir_renames, &iter);2816while((e =hashmap_iter_next(&iter))) {2817free(e->dir);2818strbuf_release(&e->new_dir);2819/* possible_new_dirs already cleared in get_directory_renames */2820}2821hashmap_free(dir_renames,1);2822free(dir_renames);28232824free(pairs->queue);2825free(pairs);2826}28272828static inthandle_renames(struct merge_options *o,2829struct tree *common,2830struct tree *head,2831struct tree *merge,2832struct string_list *entries,2833struct rename_info *ri)2834{2835struct diff_queue_struct *head_pairs, *merge_pairs;2836struct hashmap *dir_re_head, *dir_re_merge;2837int clean =1;28382839 ri->head_renames = NULL;2840 ri->merge_renames = NULL;28412842if(!merge_detect_rename(o))2843return1;28442845 head_pairs =get_diffpairs(o, common, head);2846 merge_pairs =get_diffpairs(o, common, merge);28472848 dir_re_head =get_directory_renames(head_pairs, head);2849 dir_re_merge =get_directory_renames(merge_pairs, merge);28502851handle_directory_level_conflicts(o,2852 dir_re_head, head,2853 dir_re_merge, merge);28542855 ri->head_renames =get_renames(o, head_pairs,2856 dir_re_merge, dir_re_head, head,2857 common, head, merge, entries,2858&clean);2859if(clean <0)2860goto cleanup;2861 ri->merge_renames =get_renames(o, merge_pairs,2862 dir_re_head, dir_re_merge, merge,2863 common, head, merge, entries,2864&clean);2865if(clean <0)2866goto cleanup;2867 clean &=process_renames(o, ri->head_renames, ri->merge_renames);28682869cleanup:2870/*2871 * Some cleanup is deferred until cleanup_renames() because the2872 * data structures are still needed and referenced in2873 * process_entry(). But there are a few things we can free now.2874 */2875initial_cleanup_rename(head_pairs, dir_re_head);2876initial_cleanup_rename(merge_pairs, dir_re_merge);28772878return clean;2879}28802881static voidfinal_cleanup_rename(struct string_list *rename)2882{2883const struct rename *re;2884int i;28852886if(rename == NULL)2887return;28882889for(i =0; i < rename->nr; i++) {2890 re = rename->items[i].util;2891diff_free_filepair(re->pair);2892}2893string_list_clear(rename,1);2894free(rename);2895}28962897static voidfinal_cleanup_renames(struct rename_info *re_info)2898{2899final_cleanup_rename(re_info->head_renames);2900final_cleanup_rename(re_info->merge_renames);2901}29022903static struct object_id *stage_oid(const struct object_id *oid,unsigned mode)2904{2905return(is_null_oid(oid) || mode ==0) ? NULL: (struct object_id *)oid;2906}29072908static intread_oid_strbuf(struct merge_options *o,2909const struct object_id *oid,struct strbuf *dst)2910{2911void*buf;2912enum object_type type;2913unsigned long size;2914 buf =read_object_file(oid, &type, &size);2915if(!buf)2916returnerr(o,_("cannot read object%s"),oid_to_hex(oid));2917if(type != OBJ_BLOB) {2918free(buf);2919returnerr(o,_("object%sis not a blob"),oid_to_hex(oid));2920}2921strbuf_attach(dst, buf, size, size +1);2922return0;2923}29242925static intblob_unchanged(struct merge_options *opt,2926const struct object_id *o_oid,2927unsigned o_mode,2928const struct object_id *a_oid,2929unsigned a_mode,2930int renormalize,const char*path)2931{2932struct strbuf o = STRBUF_INIT;2933struct strbuf a = STRBUF_INIT;2934int ret =0;/* assume changed for safety */29352936if(a_mode != o_mode)2937return0;2938if(oid_eq(o_oid, a_oid))2939return1;2940if(!renormalize)2941return0;29422943assert(o_oid && a_oid);2944if(read_oid_strbuf(opt, o_oid, &o) ||read_oid_strbuf(opt, a_oid, &a))2945goto error_return;2946/*2947 * Note: binary | is used so that both renormalizations are2948 * performed. Comparison can be skipped if both files are2949 * unchanged since their sha1s have already been compared.2950 */2951if(renormalize_buffer(&the_index, path, o.buf, o.len, &o) |2952renormalize_buffer(&the_index, path, a.buf, a.len, &a))2953 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));29542955error_return:2956strbuf_release(&o);2957strbuf_release(&a);2958return ret;2959}29602961static inthandle_modify_delete(struct merge_options *o,2962const char*path,2963struct object_id *o_oid,int o_mode,2964struct object_id *a_oid,int a_mode,2965struct object_id *b_oid,int b_mode)2966{2967const char*modify_branch, *delete_branch;2968struct object_id *changed_oid;2969int changed_mode;29702971if(a_oid) {2972 modify_branch = o->branch1;2973 delete_branch = o->branch2;2974 changed_oid = a_oid;2975 changed_mode = a_mode;2976}else{2977 modify_branch = o->branch2;2978 delete_branch = o->branch1;2979 changed_oid = b_oid;2980 changed_mode = b_mode;2981}29822983returnhandle_change_delete(o,2984 path, NULL,2985 o_oid, o_mode,2986 changed_oid, changed_mode,2987 modify_branch, delete_branch,2988_("modify"),_("modified"));2989}29902991static intmerge_content(struct merge_options *o,2992const char*path,2993int is_dirty,2994struct object_id *o_oid,int o_mode,2995struct object_id *a_oid,int a_mode,2996struct object_id *b_oid,int b_mode,2997struct rename_conflict_info *rename_conflict_info)2998{2999const char*reason =_("content");3000const char*path1 = NULL, *path2 = NULL;3001struct merge_file_info mfi;3002struct diff_filespec one, a, b;3003unsigned df_conflict_remains =0;30043005if(!o_oid) {3006 reason =_("add/add");3007 o_oid = (struct object_id *)&null_oid;3008}3009 one.path = a.path = b.path = (char*)path;3010oidcpy(&one.oid, o_oid);3011 one.mode = o_mode;3012oidcpy(&a.oid, a_oid);3013 a.mode = a_mode;3014oidcpy(&b.oid, b_oid);3015 b.mode = b_mode;30163017if(rename_conflict_info) {3018struct diff_filepair *pair1 = rename_conflict_info->pair1;30193020 path1 = (o->branch1 == rename_conflict_info->branch1) ?3021 pair1->two->path : pair1->one->path;3022/* If rename_conflict_info->pair2 != NULL, we are in3023 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a3024 * normal rename.3025 */3026 path2 = (rename_conflict_info->pair2 ||3027 o->branch2 == rename_conflict_info->branch1) ?3028 pair1->two->path : pair1->one->path;30293030if(dir_in_way(path, !o->call_depth,3031S_ISGITLINK(pair1->two->mode)))3032 df_conflict_remains =1;3033}3034if(merge_file_special_markers(o, &one, &a, &b, path,3035 o->branch1, path1,3036 o->branch2, path2, &mfi))3037return-1;30383039/*3040 * We can skip updating the working tree file iff:3041 * a) The merge is clean3042 * b) The merge matches what was in HEAD (content, mode, pathname)3043 * c) The target path is usable (i.e. not involved in D/F conflict)3044 */3045if(mfi.clean &&3046was_tracked_and_matches(o, path, &mfi.oid, mfi.mode) &&3047!df_conflict_remains) {3048output(o,3,_("Skipped%s(merged same as existing)"), path);3049if(add_cacheinfo(o, mfi.mode, &mfi.oid, path,30500, (!o->call_depth && !is_dirty),0))3051return-1;3052return mfi.clean;3053}30543055if(!mfi.clean) {3056if(S_ISGITLINK(mfi.mode))3057 reason =_("submodule");3058output(o,1,_("CONFLICT (%s): Merge conflict in%s"),3059 reason, path);3060if(rename_conflict_info && !df_conflict_remains)3061if(update_stages(o, path, &one, &a, &b))3062return-1;3063}30643065if(df_conflict_remains || is_dirty) {3066char*new_path;3067if(o->call_depth) {3068remove_file_from_cache(path);3069}else{3070if(!mfi.clean) {3071if(update_stages(o, path, &one, &a, &b))3072return-1;3073}else{3074int file_from_stage2 =was_tracked(o, path);3075struct diff_filespec merged;3076oidcpy(&merged.oid, &mfi.oid);3077 merged.mode = mfi.mode;30783079if(update_stages(o, path, NULL,3080 file_from_stage2 ? &merged : NULL,3081 file_from_stage2 ? NULL : &merged))3082return-1;3083}30843085}3086 new_path =unique_path(o, path, rename_conflict_info->branch1);3087if(is_dirty) {3088output(o,1,_("Refusing to lose dirty file at%s"),3089 path);3090}3091output(o,1,_("Adding as%sinstead"), new_path);3092if(update_file(o,0, &mfi.oid, mfi.mode, new_path)) {3093free(new_path);3094return-1;3095}3096free(new_path);3097 mfi.clean =0;3098}else if(update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))3099return-1;3100return!is_dirty && mfi.clean;3101}31023103static intconflict_rename_normal(struct merge_options *o,3104const char*path,3105struct object_id *o_oid,unsigned int o_mode,3106struct object_id *a_oid,unsigned int a_mode,3107struct object_id *b_oid,unsigned int b_mode,3108struct rename_conflict_info *ci)3109{3110/* Merge the content and write it out */3111returnmerge_content(o, path,was_dirty(o, path),3112 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3113 ci);3114}31153116/* Per entry merge function */3117static intprocess_entry(struct merge_options *o,3118const char*path,struct stage_data *entry)3119{3120int clean_merge =1;3121int normalize = o->renormalize;3122unsigned o_mode = entry->stages[1].mode;3123unsigned a_mode = entry->stages[2].mode;3124unsigned b_mode = entry->stages[3].mode;3125struct object_id *o_oid =stage_oid(&entry->stages[1].oid, o_mode);3126struct object_id *a_oid =stage_oid(&entry->stages[2].oid, a_mode);3127struct object_id *b_oid =stage_oid(&entry->stages[3].oid, b_mode);31283129 entry->processed =1;3130if(entry->rename_conflict_info) {3131struct rename_conflict_info *conflict_info = entry->rename_conflict_info;3132switch(conflict_info->rename_type) {3133case RENAME_NORMAL:3134case RENAME_ONE_FILE_TO_ONE:3135 clean_merge =conflict_rename_normal(o,3136 path,3137 o_oid, o_mode,3138 a_oid, a_mode,3139 b_oid, b_mode,3140 conflict_info);3141break;3142case RENAME_DIR:3143 clean_merge =1;3144if(conflict_rename_dir(o,3145 conflict_info->pair1,3146 conflict_info->branch1,3147 conflict_info->branch2))3148 clean_merge = -1;3149break;3150case RENAME_DELETE:3151 clean_merge =0;3152if(conflict_rename_delete(o,3153 conflict_info->pair1,3154 conflict_info->branch1,3155 conflict_info->branch2))3156 clean_merge = -1;3157break;3158case RENAME_ONE_FILE_TO_TWO:3159 clean_merge =0;3160if(conflict_rename_rename_1to2(o, conflict_info))3161 clean_merge = -1;3162break;3163case RENAME_TWO_FILES_TO_ONE:3164 clean_merge =0;3165if(conflict_rename_rename_2to1(o, conflict_info))3166 clean_merge = -1;3167break;3168default:3169 entry->processed =0;3170break;3171}3172}else if(o_oid && (!a_oid || !b_oid)) {3173/* Case A: Deleted in one */3174if((!a_oid && !b_oid) ||3175(!b_oid &&blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||3176(!a_oid &&blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {3177/* Deleted in both or deleted in one and3178 * unchanged in the other */3179if(a_oid)3180output(o,2,_("Removing%s"), path);3181/* do not touch working file if it did not exist */3182remove_file(o,1, path, !a_oid);3183}else{3184/* Modify/delete; deleted side may have put a directory in the way */3185 clean_merge =0;3186if(handle_modify_delete(o, path, o_oid, o_mode,3187 a_oid, a_mode, b_oid, b_mode))3188 clean_merge = -1;3189}3190}else if((!o_oid && a_oid && !b_oid) ||3191(!o_oid && !a_oid && b_oid)) {3192/* Case B: Added in one. */3193/* [nothing|directory] -> ([nothing|directory], file) */31943195const char*add_branch;3196const char*other_branch;3197unsigned mode;3198const struct object_id *oid;3199const char*conf;32003201if(a_oid) {3202 add_branch = o->branch1;3203 other_branch = o->branch2;3204 mode = a_mode;3205 oid = a_oid;3206 conf =_("file/directory");3207}else{3208 add_branch = o->branch2;3209 other_branch = o->branch1;3210 mode = b_mode;3211 oid = b_oid;3212 conf =_("directory/file");3213}3214if(dir_in_way(path,3215!o->call_depth && !S_ISGITLINK(a_mode),32160)) {3217char*new_path =unique_path(o, path, add_branch);3218 clean_merge =0;3219output(o,1,_("CONFLICT (%s): There is a directory with name%sin%s. "3220"Adding%sas%s"),3221 conf, path, other_branch, path, new_path);3222if(update_file(o,0, oid, mode, new_path))3223 clean_merge = -1;3224else if(o->call_depth)3225remove_file_from_cache(path);3226free(new_path);3227}else{3228output(o,2,_("Adding%s"), path);3229/* do not overwrite file if already present */3230if(update_file_flags(o, oid, mode, path,1, !a_oid))3231 clean_merge = -1;3232}3233}else if(a_oid && b_oid) {3234/* Case C: Added in both (check for same permissions) and */3235/* case D: Modified in both, but differently. */3236int is_dirty =0;/* unpack_trees would have bailed if dirty */3237 clean_merge =merge_content(o, path, is_dirty,3238 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3239 NULL);3240}else if(!o_oid && !a_oid && !b_oid) {3241/*3242 * this entry was deleted altogether. a_mode == 0 means3243 * we had that path and want to actively remove it.3244 */3245remove_file(o,1, path, !a_mode);3246}else3247BUG("fatal merge failure, shouldn't happen.");32483249return clean_merge;3250}32513252intmerge_trees(struct merge_options *o,3253struct tree *head,3254struct tree *merge,3255struct tree *common,3256struct tree **result)3257{3258int code, clean;32593260if(o->subtree_shift) {3261 merge =shift_tree_object(head, merge, o->subtree_shift);3262 common =shift_tree_object(head, common, o->subtree_shift);3263}32643265if(oid_eq(&common->object.oid, &merge->object.oid)) {3266struct strbuf sb = STRBUF_INIT;32673268if(!o->call_depth &&index_has_changes(&sb)) {3269err(o,_("Dirty index: cannot merge (dirty:%s)"),3270 sb.buf);3271return0;3272}3273output(o,0,_("Already up to date!"));3274*result = head;3275return1;3276}32773278 code =unpack_trees_start(o, common, head, merge);32793280if(code !=0) {3281if(show(o,4) || o->call_depth)3282err(o,_("merging of trees%sand%sfailed"),3283oid_to_hex(&head->object.oid),3284oid_to_hex(&merge->object.oid));3285unpack_trees_finish(o);3286return-1;3287}32883289if(unmerged_cache()) {3290struct string_list *entries;3291struct rename_info re_info;3292int i;3293/*3294 * Only need the hashmap while processing entries, so3295 * initialize it here and free it when we are done running3296 * through the entries. Keeping it in the merge_options as3297 * opposed to decaring a local hashmap is for convenience3298 * so that we don't have to pass it to around.3299 */3300hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL,512);3301get_files_dirs(o, head);3302get_files_dirs(o, merge);33033304 entries =get_unmerged();3305 clean =handle_renames(o, common, head, merge, entries,3306&re_info);3307record_df_conflict_files(o, entries);3308if(clean <0)3309goto cleanup;3310for(i = entries->nr-1;0<= i; i--) {3311const char*path = entries->items[i].string;3312struct stage_data *e = entries->items[i].util;3313if(!e->processed) {3314int ret =process_entry(o, path, e);3315if(!ret)3316 clean =0;3317else if(ret <0) {3318 clean = ret;3319goto cleanup;3320}3321}3322}3323for(i =0; i < entries->nr; i++) {3324struct stage_data *e = entries->items[i].util;3325if(!e->processed)3326BUG("unprocessed path???%s",3327 entries->items[i].string);3328}33293330cleanup:3331final_cleanup_renames(&re_info);33323333string_list_clear(entries,1);3334free(entries);33353336hashmap_free(&o->current_file_dir_set,1);33373338if(clean <0) {3339unpack_trees_finish(o);3340return clean;3341}3342}3343else3344 clean =1;33453346unpack_trees_finish(o);33473348if(o->call_depth && !(*result =write_tree_from_memory(o)))3349return-1;33503351return clean;3352}33533354static struct commit_list *reverse_commit_list(struct commit_list *list)3355{3356struct commit_list *next = NULL, *current, *backup;3357for(current = list; current; current = backup) {3358 backup = current->next;3359 current->next = next;3360 next = current;3361}3362return next;3363}33643365/*3366 * Merge the commits h1 and h2, return the resulting virtual3367 * commit object and a flag indicating the cleanness of the merge.3368 */3369intmerge_recursive(struct merge_options *o,3370struct commit *h1,3371struct commit *h2,3372struct commit_list *ca,3373struct commit **result)3374{3375struct commit_list *iter;3376struct commit *merged_common_ancestors;3377struct tree *mrtree;3378int clean;33793380if(show(o,4)) {3381output(o,4,_("Merging:"));3382output_commit_title(o, h1);3383output_commit_title(o, h2);3384}33853386if(!ca) {3387 ca =get_merge_bases(h1, h2);3388 ca =reverse_commit_list(ca);3389}33903391if(show(o,5)) {3392unsigned cnt =commit_list_count(ca);33933394output(o,5,Q_("found%ucommon ancestor:",3395"found%ucommon ancestors:", cnt), cnt);3396for(iter = ca; iter; iter = iter->next)3397output_commit_title(o, iter->item);3398}33993400 merged_common_ancestors =pop_commit(&ca);3401if(merged_common_ancestors == NULL) {3402/* if there is no common ancestor, use an empty tree */3403struct tree *tree;34043405 tree =lookup_tree(the_hash_algo->empty_tree);3406 merged_common_ancestors =make_virtual_commit(tree,"ancestor");3407}34083409for(iter = ca; iter; iter = iter->next) {3410const char*saved_b1, *saved_b2;3411 o->call_depth++;3412/*3413 * When the merge fails, the result contains files3414 * with conflict markers. The cleanness flag is3415 * ignored (unless indicating an error), it was never3416 * actually used, as result of merge_trees has always3417 * overwritten it: the committed "conflicts" were3418 * already resolved.3419 */3420discard_cache();3421 saved_b1 = o->branch1;3422 saved_b2 = o->branch2;3423 o->branch1 ="Temporary merge branch 1";3424 o->branch2 ="Temporary merge branch 2";3425if(merge_recursive(o, merged_common_ancestors, iter->item,3426 NULL, &merged_common_ancestors) <0)3427return-1;3428 o->branch1 = saved_b1;3429 o->branch2 = saved_b2;3430 o->call_depth--;34313432if(!merged_common_ancestors)3433returnerr(o,_("merge returned no commit"));3434}34353436discard_cache();3437if(!o->call_depth)3438read_cache();34393440 o->ancestor ="merged common ancestors";3441 clean =merge_trees(o,get_commit_tree(h1),get_commit_tree(h2),3442get_commit_tree(merged_common_ancestors),3443&mrtree);3444if(clean <0) {3445flush_output(o);3446return clean;3447}34483449if(o->call_depth) {3450*result =make_virtual_commit(mrtree,"merged tree");3451commit_list_insert(h1, &(*result)->parents);3452commit_list_insert(h2, &(*result)->parents->next);3453}3454flush_output(o);3455if(!o->call_depth && o->buffer_output <2)3456strbuf_release(&o->obuf);3457if(show(o,2))3458diff_warn_rename_limit("merge.renamelimit",3459 o->needed_rename_limit,0);3460return clean;3461}34623463static struct commit *get_ref(const struct object_id *oid,const char*name)3464{3465struct object *object;34663467 object =deref_tag(parse_object(oid), name,strlen(name));3468if(!object)3469return NULL;3470if(object->type == OBJ_TREE)3471returnmake_virtual_commit((struct tree*)object, name);3472if(object->type != OBJ_COMMIT)3473return NULL;3474if(parse_commit((struct commit *)object))3475return NULL;3476return(struct commit *)object;3477}34783479intmerge_recursive_generic(struct merge_options *o,3480const struct object_id *head,3481const struct object_id *merge,3482int num_base_list,3483const struct object_id **base_list,3484struct commit **result)3485{3486int clean;3487struct lock_file lock = LOCK_INIT;3488struct commit *head_commit =get_ref(head, o->branch1);3489struct commit *next_commit =get_ref(merge, o->branch2);3490struct commit_list *ca = NULL;34913492if(base_list) {3493int i;3494for(i =0; i < num_base_list; ++i) {3495struct commit *base;3496if(!(base =get_ref(base_list[i],oid_to_hex(base_list[i]))))3497returnerr(o,_("Could not parse object '%s'"),3498oid_to_hex(base_list[i]));3499commit_list_insert(base, &ca);3500}3501}35023503hold_locked_index(&lock, LOCK_DIE_ON_ERROR);3504 clean =merge_recursive(o, head_commit, next_commit, ca,3505 result);3506if(clean <0) {3507rollback_lock_file(&lock);3508return clean;3509}35103511if(write_locked_index(&the_index, &lock,3512 COMMIT_LOCK | SKIP_IF_UNCHANGED))3513returnerr(o,_("Unable to write index."));35143515return clean ?0:1;3516}35173518static voidmerge_recursive_config(struct merge_options *o)3519{3520char*value = NULL;3521git_config_get_int("merge.verbosity", &o->verbosity);3522git_config_get_int("diff.renamelimit", &o->diff_rename_limit);3523git_config_get_int("merge.renamelimit", &o->merge_rename_limit);3524if(!git_config_get_string("diff.renames", &value)) {3525 o->diff_detect_rename =git_config_rename("diff.renames", value);3526free(value);3527}3528if(!git_config_get_string("merge.renames", &value)) {3529 o->merge_detect_rename =git_config_rename("merge.renames", value);3530free(value);3531}3532git_config(git_xmerge_config, NULL);3533}35343535voidinit_merge_options(struct merge_options *o)3536{3537const char*merge_verbosity;3538memset(o,0,sizeof(struct merge_options));3539 o->verbosity =2;3540 o->buffer_output =1;3541 o->diff_rename_limit = -1;3542 o->merge_rename_limit = -1;3543 o->renormalize =0;3544 o->diff_detect_rename = -1;3545 o->merge_detect_rename = -1;3546merge_recursive_config(o);3547 merge_verbosity =getenv("GIT_MERGE_VERBOSITY");3548if(merge_verbosity)3549 o->verbosity =strtol(merge_verbosity, NULL,10);3550if(o->verbosity >=5)3551 o->buffer_output =0;3552strbuf_init(&o->obuf,0);3553string_list_init(&o->df_conflict_file_set,1);3554}35553556intparse_merge_opt(struct merge_options *o,const char*s)3557{3558const char*arg;35593560if(!s || !*s)3561return-1;3562if(!strcmp(s,"ours"))3563 o->recursive_variant = MERGE_RECURSIVE_OURS;3564else if(!strcmp(s,"theirs"))3565 o->recursive_variant = MERGE_RECURSIVE_THEIRS;3566else if(!strcmp(s,"subtree"))3567 o->subtree_shift ="";3568else if(skip_prefix(s,"subtree=", &arg))3569 o->subtree_shift = arg;3570else if(!strcmp(s,"patience"))3571 o->xdl_opts =DIFF_WITH_ALG(o, PATIENCE_DIFF);3572else if(!strcmp(s,"histogram"))3573 o->xdl_opts =DIFF_WITH_ALG(o, HISTOGRAM_DIFF);3574else if(skip_prefix(s,"diff-algorithm=", &arg)) {3575long value =parse_algorithm_value(arg);3576if(value <0)3577return-1;3578/* clear out previous settings */3579DIFF_XDL_CLR(o, NEED_MINIMAL);3580 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3581 o->xdl_opts |= value;3582}3583else if(!strcmp(s,"ignore-space-change"))3584DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);3585else if(!strcmp(s,"ignore-all-space"))3586DIFF_XDL_SET(o, IGNORE_WHITESPACE);3587else if(!strcmp(s,"ignore-space-at-eol"))3588DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);3589else if(!strcmp(s,"ignore-cr-at-eol"))3590DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);3591else if(!strcmp(s,"renormalize"))3592 o->renormalize =1;3593else if(!strcmp(s,"no-renormalize"))3594 o->renormalize =0;3595else if(!strcmp(s,"no-renames"))3596 o->merge_detect_rename =0;3597else if(!strcmp(s,"find-renames")) {3598 o->merge_detect_rename =1;3599 o->rename_score =0;3600}3601else if(skip_prefix(s,"find-renames=", &arg) ||3602skip_prefix(s,"rename-threshold=", &arg)) {3603if((o->rename_score =parse_rename_score(&arg)) == -1|| *arg !=0)3604return-1;3605 o->merge_detect_rename =1;3606}3607else3608return-1;3609return0;3610}