1/* 2 * Recursive Merge algorithm stolen from git-merge-recursive.py by 3 * Fredrik Kuivinen. 4 * The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006 5 */ 6#include"cache.h" 7#include"config.h" 8#include"advice.h" 9#include"lockfile.h" 10#include"cache-tree.h" 11#include"object-store.h" 12#include"repository.h" 13#include"commit.h" 14#include"blob.h" 15#include"builtin.h" 16#include"tree-walk.h" 17#include"diff.h" 18#include"diffcore.h" 19#include"tag.h" 20#include"alloc.h" 21#include"unpack-trees.h" 22#include"string-list.h" 23#include"xdiff-interface.h" 24#include"ll-merge.h" 25#include"attr.h" 26#include"merge-recursive.h" 27#include"dir.h" 28#include"submodule.h" 29#include"revision.h" 30#include"commit-reach.h" 31 32struct path_hashmap_entry { 33struct hashmap_entry e; 34char path[FLEX_ARRAY]; 35}; 36 37static intpath_hashmap_cmp(const void*cmp_data, 38const void*entry, 39const void*entry_or_key, 40const void*keydata) 41{ 42const struct path_hashmap_entry *a = entry; 43const struct path_hashmap_entry *b = entry_or_key; 44const char*key = keydata; 45 46if(ignore_case) 47returnstrcasecmp(a->path, key ? key : b->path); 48else 49returnstrcmp(a->path, key ? key : b->path); 50} 51 52static unsigned intpath_hash(const char*path) 53{ 54return ignore_case ?strihash(path) :strhash(path); 55} 56 57static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap, 58char*dir) 59{ 60struct dir_rename_entry key; 61 62if(dir == NULL) 63return NULL; 64hashmap_entry_init(&key,strhash(dir)); 65 key.dir = dir; 66returnhashmap_get(hashmap, &key, NULL); 67} 68 69static intdir_rename_cmp(const void*unused_cmp_data, 70const void*entry, 71const void*entry_or_key, 72const void*unused_keydata) 73{ 74const struct dir_rename_entry *e1 = entry; 75const struct dir_rename_entry *e2 = entry_or_key; 76 77returnstrcmp(e1->dir, e2->dir); 78} 79 80static voiddir_rename_init(struct hashmap *map) 81{ 82hashmap_init(map, dir_rename_cmp, NULL,0); 83} 84 85static voiddir_rename_entry_init(struct dir_rename_entry *entry, 86char*directory) 87{ 88hashmap_entry_init(entry,strhash(directory)); 89 entry->dir = directory; 90 entry->non_unique_new_dir =0; 91strbuf_init(&entry->new_dir,0); 92string_list_init(&entry->possible_new_dirs,0); 93} 94 95static struct collision_entry *collision_find_entry(struct hashmap *hashmap, 96char*target_file) 97{ 98struct collision_entry key; 99 100hashmap_entry_init(&key,strhash(target_file)); 101 key.target_file = target_file; 102returnhashmap_get(hashmap, &key, NULL); 103} 104 105static intcollision_cmp(void*unused_cmp_data, 106const struct collision_entry *e1, 107const struct collision_entry *e2, 108const void*unused_keydata) 109{ 110returnstrcmp(e1->target_file, e2->target_file); 111} 112 113static voidcollision_init(struct hashmap *map) 114{ 115hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL,0); 116} 117 118static voidflush_output(struct merge_options *opt) 119{ 120if(opt->buffer_output <2&& opt->obuf.len) { 121fputs(opt->obuf.buf, stdout); 122strbuf_reset(&opt->obuf); 123} 124} 125 126static interr(struct merge_options *opt,const char*err, ...) 127{ 128va_list params; 129 130if(opt->buffer_output <2) 131flush_output(opt); 132else{ 133strbuf_complete(&opt->obuf,'\n'); 134strbuf_addstr(&opt->obuf,"error: "); 135} 136va_start(params, err); 137strbuf_vaddf(&opt->obuf, err, params); 138va_end(params); 139if(opt->buffer_output >1) 140strbuf_addch(&opt->obuf,'\n'); 141else{ 142error("%s", opt->obuf.buf); 143strbuf_reset(&opt->obuf); 144} 145 146return-1; 147} 148 149static struct tree *shift_tree_object(struct repository *repo, 150struct tree *one,struct tree *two, 151const char*subtree_shift) 152{ 153struct object_id shifted; 154 155if(!*subtree_shift) { 156shift_tree(&one->object.oid, &two->object.oid, &shifted,0); 157}else{ 158shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 159 subtree_shift); 160} 161if(oideq(&two->object.oid, &shifted)) 162return two; 163returnlookup_tree(repo, &shifted); 164} 165 166static struct commit *make_virtual_commit(struct repository *repo, 167struct tree *tree, 168const char*comment) 169{ 170struct commit *commit =alloc_commit_node(repo); 171 172set_merge_remote_desc(commit, comment, (struct object *)commit); 173 commit->maybe_tree = tree; 174 commit->object.parsed =1; 175return commit; 176} 177 178/* 179 * Since we use get_tree_entry(), which does not put the read object into 180 * the object pool, we cannot rely on a == b. 181 */ 182static intoid_eq(const struct object_id *a,const struct object_id *b) 183{ 184if(!a && !b) 185return2; 186return a && b &&oideq(a, b); 187} 188 189enum rename_type { 190 RENAME_NORMAL =0, 191 RENAME_VIA_DIR, 192 RENAME_ADD, 193 RENAME_DELETE, 194 RENAME_ONE_FILE_TO_ONE, 195 RENAME_ONE_FILE_TO_TWO, 196 RENAME_TWO_FILES_TO_ONE 197}; 198 199/* 200 * Since we want to write the index eventually, we cannot reuse the index 201 * for these (temporary) data. 202 */ 203struct stage_data { 204struct diff_filespec stages[4];/* mostly for oid & mode; maybe path */ 205struct rename_conflict_info *rename_conflict_info; 206unsigned processed:1; 207}; 208 209struct rename { 210unsigned processed:1; 211struct diff_filepair *pair; 212const char*branch;/* branch that the rename occurred on */ 213/* 214 * If directory rename detection affected this rename, what was its 215 * original type ('A' or 'R') and it's original destination before 216 * the directory rename (otherwise, '\0' and NULL for these two vars). 217 */ 218char dir_rename_original_type; 219char*dir_rename_original_dest; 220/* 221 * Purpose of src_entry and dst_entry: 222 * 223 * If 'before' is renamed to 'after' then src_entry will contain 224 * the versions of 'before' from the merge_base, HEAD, and MERGE in 225 * stages 1, 2, and 3; dst_entry will contain the respective 226 * versions of 'after' in corresponding locations. Thus, we have a 227 * total of six modes and oids, though some will be null. (Stage 0 228 * is ignored; we're interested in handling conflicts.) 229 * 230 * Since we don't turn on break-rewrites by default, neither 231 * src_entry nor dst_entry can have all three of their stages have 232 * non-null oids, meaning at most four of the six will be non-null. 233 * Also, since this is a rename, both src_entry and dst_entry will 234 * have at least one non-null oid, meaning at least two will be 235 * non-null. Of the six oids, a typical rename will have three be 236 * non-null. Only two implies a rename/delete, and four implies a 237 * rename/add. 238 */ 239struct stage_data *src_entry; 240struct stage_data *dst_entry; 241}; 242 243struct rename_conflict_info { 244enum rename_type rename_type; 245struct rename *ren1; 246struct rename *ren2; 247}; 248 249staticinlinevoidsetup_rename_conflict_info(enum rename_type rename_type, 250struct merge_options *opt, 251struct rename *ren1, 252struct rename *ren2) 253{ 254struct rename_conflict_info *ci; 255 256/* 257 * When we have two renames involved, it's easiest to get the 258 * correct things into stage 2 and 3, and to make sure that the 259 * content merge puts HEAD before the other branch if we just 260 * ensure that branch1 == opt->branch1. So, simply flip arguments 261 * around if we don't have that. 262 */ 263if(ren2 && ren1->branch != opt->branch1) { 264setup_rename_conflict_info(rename_type, opt, ren2, ren1); 265return; 266} 267 268 ci =xcalloc(1,sizeof(struct rename_conflict_info)); 269 ci->rename_type = rename_type; 270 ci->ren1 = ren1; 271 ci->ren2 = ren2; 272 273 ci->ren1->dst_entry->processed =0; 274 ci->ren1->dst_entry->rename_conflict_info = ci; 275if(ren2) { 276 ci->ren2->dst_entry->rename_conflict_info = ci; 277} 278} 279 280static intshow(struct merge_options *opt,int v) 281{ 282return(!opt->call_depth && opt->verbosity >= v) || opt->verbosity >=5; 283} 284 285__attribute__((format(printf,3,4))) 286static voidoutput(struct merge_options *opt,int v,const char*fmt, ...) 287{ 288va_list ap; 289 290if(!show(opt, v)) 291return; 292 293strbuf_addchars(&opt->obuf,' ', opt->call_depth *2); 294 295va_start(ap, fmt); 296strbuf_vaddf(&opt->obuf, fmt, ap); 297va_end(ap); 298 299strbuf_addch(&opt->obuf,'\n'); 300if(!opt->buffer_output) 301flush_output(opt); 302} 303 304static voidoutput_commit_title(struct merge_options *opt,struct commit *commit) 305{ 306struct merge_remote_desc *desc; 307 308strbuf_addchars(&opt->obuf,' ', opt->call_depth *2); 309 desc =merge_remote_util(commit); 310if(desc) 311strbuf_addf(&opt->obuf,"virtual%s\n", desc->name); 312else{ 313strbuf_add_unique_abbrev(&opt->obuf, &commit->object.oid, 314 DEFAULT_ABBREV); 315strbuf_addch(&opt->obuf,' '); 316if(parse_commit(commit) !=0) 317strbuf_addstr(&opt->obuf,_("(bad commit)\n")); 318else{ 319const char*title; 320const char*msg =get_commit_buffer(commit, NULL); 321int len =find_commit_subject(msg, &title); 322if(len) 323strbuf_addf(&opt->obuf,"%.*s\n", len, title); 324unuse_commit_buffer(commit, msg); 325} 326} 327flush_output(opt); 328} 329 330static intadd_cacheinfo(struct merge_options *opt, 331const struct diff_filespec *blob, 332const char*path,int stage,int refresh,int options) 333{ 334struct index_state *istate = opt->repo->index; 335struct cache_entry *ce; 336int ret; 337 338 ce =make_cache_entry(istate, blob->mode, &blob->oid, path, stage,0); 339if(!ce) 340returnerr(opt,_("add_cacheinfo failed for path '%s'; merge aborting."), path); 341 342 ret =add_index_entry(istate, ce, options); 343if(refresh) { 344struct cache_entry *nce; 345 346 nce =refresh_cache_entry(istate, ce, 347 CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 348if(!nce) 349returnerr(opt,_("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); 350if(nce != ce) 351 ret =add_index_entry(istate, nce, options); 352} 353return ret; 354} 355 356static voidinit_tree_desc_from_tree(struct tree_desc *desc,struct tree *tree) 357{ 358parse_tree(tree); 359init_tree_desc(desc, tree->buffer, tree->size); 360} 361 362static intunpack_trees_start(struct merge_options *opt, 363struct tree *common, 364struct tree *head, 365struct tree *merge) 366{ 367int rc; 368struct tree_desc t[3]; 369struct index_state tmp_index = { NULL }; 370 371memset(&opt->unpack_opts,0,sizeof(opt->unpack_opts)); 372if(opt->call_depth) 373 opt->unpack_opts.index_only =1; 374else 375 opt->unpack_opts.update =1; 376 opt->unpack_opts.merge =1; 377 opt->unpack_opts.head_idx =2; 378 opt->unpack_opts.fn = threeway_merge; 379 opt->unpack_opts.src_index = opt->repo->index; 380 opt->unpack_opts.dst_index = &tmp_index; 381 opt->unpack_opts.aggressive = !merge_detect_rename(opt); 382setup_unpack_trees_porcelain(&opt->unpack_opts,"merge"); 383 384init_tree_desc_from_tree(t+0, common); 385init_tree_desc_from_tree(t+1, head); 386init_tree_desc_from_tree(t+2, merge); 387 388 rc =unpack_trees(3, t, &opt->unpack_opts); 389cache_tree_free(&opt->repo->index->cache_tree); 390 391/* 392 * Update opt->repo->index to match the new results, AFTER saving a copy 393 * in opt->orig_index. Update src_index to point to the saved copy. 394 * (verify_uptodate() checks src_index, and the original index is 395 * the one that had the necessary modification timestamps.) 396 */ 397 opt->orig_index = *opt->repo->index; 398*opt->repo->index = tmp_index; 399 opt->unpack_opts.src_index = &opt->orig_index; 400 401return rc; 402} 403 404static voidunpack_trees_finish(struct merge_options *opt) 405{ 406discard_index(&opt->orig_index); 407clear_unpack_trees_porcelain(&opt->unpack_opts); 408} 409 410struct tree *write_tree_from_memory(struct merge_options *opt) 411{ 412struct tree *result = NULL; 413struct index_state *istate = opt->repo->index; 414 415if(unmerged_index(istate)) { 416int i; 417fprintf(stderr,"BUG: There are unmerged index entries:\n"); 418for(i =0; i < istate->cache_nr; i++) { 419const struct cache_entry *ce = istate->cache[i]; 420if(ce_stage(ce)) 421fprintf(stderr,"BUG:%d%.*s\n",ce_stage(ce), 422(int)ce_namelen(ce), ce->name); 423} 424BUG("unmerged index entries in merge-recursive.c"); 425} 426 427if(!istate->cache_tree) 428 istate->cache_tree =cache_tree(); 429 430if(!cache_tree_fully_valid(istate->cache_tree) && 431cache_tree_update(istate,0) <0) { 432err(opt,_("error building trees")); 433return NULL; 434} 435 436 result =lookup_tree(opt->repo, &istate->cache_tree->oid); 437 438return result; 439} 440 441static intsave_files_dirs(const struct object_id *oid, 442struct strbuf *base,const char*path, 443unsigned int mode,int stage,void*context) 444{ 445struct path_hashmap_entry *entry; 446int baselen = base->len; 447struct merge_options *opt = context; 448 449strbuf_addstr(base, path); 450 451FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 452hashmap_entry_init(entry,path_hash(entry->path)); 453hashmap_add(&opt->current_file_dir_set, entry); 454 455strbuf_setlen(base, baselen); 456return(S_ISDIR(mode) ? READ_TREE_RECURSIVE :0); 457} 458 459static voidget_files_dirs(struct merge_options *opt,struct tree *tree) 460{ 461struct pathspec match_all; 462memset(&match_all,0,sizeof(match_all)); 463read_tree_recursive(the_repository, tree,"",0,0, 464&match_all, save_files_dirs, opt); 465} 466 467static intget_tree_entry_if_blob(const struct object_id *tree, 468const char*path, 469struct diff_filespec *dfs) 470{ 471int ret; 472 473 ret =get_tree_entry(tree, path, &dfs->oid, &dfs->mode); 474if(S_ISDIR(dfs->mode)) { 475oidcpy(&dfs->oid, &null_oid); 476 dfs->mode =0; 477} 478return ret; 479} 480 481/* 482 * Returns an index_entry instance which doesn't have to correspond to 483 * a real cache entry in Git's index. 484 */ 485static struct stage_data *insert_stage_data(const char*path, 486struct tree *o,struct tree *a,struct tree *b, 487struct string_list *entries) 488{ 489struct string_list_item *item; 490struct stage_data *e =xcalloc(1,sizeof(struct stage_data)); 491get_tree_entry_if_blob(&o->object.oid, path, &e->stages[1]); 492get_tree_entry_if_blob(&a->object.oid, path, &e->stages[2]); 493get_tree_entry_if_blob(&b->object.oid, path, &e->stages[3]); 494 item =string_list_insert(entries, path); 495 item->util = e; 496return e; 497} 498 499/* 500 * Create a dictionary mapping file names to stage_data objects. The 501 * dictionary contains one entry for every path with a non-zero stage entry. 502 */ 503static struct string_list *get_unmerged(struct index_state *istate) 504{ 505struct string_list *unmerged =xcalloc(1,sizeof(struct string_list)); 506int i; 507 508 unmerged->strdup_strings =1; 509 510for(i =0; i < istate->cache_nr; i++) { 511struct string_list_item *item; 512struct stage_data *e; 513const struct cache_entry *ce = istate->cache[i]; 514if(!ce_stage(ce)) 515continue; 516 517 item =string_list_lookup(unmerged, ce->name); 518if(!item) { 519 item =string_list_insert(unmerged, ce->name); 520 item->util =xcalloc(1,sizeof(struct stage_data)); 521} 522 e = item->util; 523 e->stages[ce_stage(ce)].mode = ce->ce_mode; 524oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 525} 526 527return unmerged; 528} 529 530static intstring_list_df_name_compare(const char*one,const char*two) 531{ 532int onelen =strlen(one); 533int twolen =strlen(two); 534/* 535 * Here we only care that entries for D/F conflicts are 536 * adjacent, in particular with the file of the D/F conflict 537 * appearing before files below the corresponding directory. 538 * The order of the rest of the list is irrelevant for us. 539 * 540 * To achieve this, we sort with df_name_compare and provide 541 * the mode S_IFDIR so that D/F conflicts will sort correctly. 542 * We use the mode S_IFDIR for everything else for simplicity, 543 * since in other cases any changes in their order due to 544 * sorting cause no problems for us. 545 */ 546int cmp =df_name_compare(one, onelen, S_IFDIR, 547 two, twolen, S_IFDIR); 548/* 549 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 550 * that 'foo' comes before 'foo/bar'. 551 */ 552if(cmp) 553return cmp; 554return onelen - twolen; 555} 556 557static voidrecord_df_conflict_files(struct merge_options *opt, 558struct string_list *entries) 559{ 560/* If there is a D/F conflict and the file for such a conflict 561 * currently exists in the working tree, we want to allow it to be 562 * removed to make room for the corresponding directory if needed. 563 * The files underneath the directories of such D/F conflicts will 564 * be processed before the corresponding file involved in the D/F 565 * conflict. If the D/F directory ends up being removed by the 566 * merge, then we won't have to touch the D/F file. If the D/F 567 * directory needs to be written to the working copy, then the D/F 568 * file will simply be removed (in make_room_for_path()) to make 569 * room for the necessary paths. Note that if both the directory 570 * and the file need to be present, then the D/F file will be 571 * reinstated with a new unique name at the time it is processed. 572 */ 573struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 574const char*last_file = NULL; 575int last_len =0; 576int i; 577 578/* 579 * If we're merging merge-bases, we don't want to bother with 580 * any working directory changes. 581 */ 582if(opt->call_depth) 583return; 584 585/* Ensure D/F conflicts are adjacent in the entries list. */ 586for(i =0; i < entries->nr; i++) { 587struct string_list_item *next = &entries->items[i]; 588string_list_append(&df_sorted_entries, next->string)->util = 589 next->util; 590} 591 df_sorted_entries.cmp = string_list_df_name_compare; 592string_list_sort(&df_sorted_entries); 593 594string_list_clear(&opt->df_conflict_file_set,1); 595for(i =0; i < df_sorted_entries.nr; i++) { 596const char*path = df_sorted_entries.items[i].string; 597int len =strlen(path); 598struct stage_data *e = df_sorted_entries.items[i].util; 599 600/* 601 * Check if last_file & path correspond to a D/F conflict; 602 * i.e. whether path is last_file+'/'+<something>. 603 * If so, record that it's okay to remove last_file to make 604 * room for path and friends if needed. 605 */ 606if(last_file && 607 len > last_len && 608memcmp(path, last_file, last_len) ==0&& 609 path[last_len] =='/') { 610string_list_insert(&opt->df_conflict_file_set, last_file); 611} 612 613/* 614 * Determine whether path could exist as a file in the 615 * working directory as a possible D/F conflict. This 616 * will only occur when it exists in stage 2 as a 617 * file. 618 */ 619if(S_ISREG(e->stages[2].mode) ||S_ISLNK(e->stages[2].mode)) { 620 last_file = path; 621 last_len = len; 622}else{ 623 last_file = NULL; 624} 625} 626string_list_clear(&df_sorted_entries,0); 627} 628 629static intupdate_stages(struct merge_options *opt,const char*path, 630const struct diff_filespec *o, 631const struct diff_filespec *a, 632const struct diff_filespec *b) 633{ 634 635/* 636 * NOTE: It is usually a bad idea to call update_stages on a path 637 * before calling update_file on that same path, since it can 638 * sometimes lead to spurious "refusing to lose untracked file..." 639 * messages from update_file (via make_room_for path via 640 * would_lose_untracked). Instead, reverse the order of the calls 641 * (executing update_file first and then update_stages). 642 */ 643int clear =1; 644int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 645if(clear) 646if(remove_file_from_index(opt->repo->index, path)) 647return-1; 648if(o) 649if(add_cacheinfo(opt, o, path,1,0, options)) 650return-1; 651if(a) 652if(add_cacheinfo(opt, a, path,2,0, options)) 653return-1; 654if(b) 655if(add_cacheinfo(opt, b, path,3,0, options)) 656return-1; 657return0; 658} 659 660static voidupdate_entry(struct stage_data *entry, 661struct diff_filespec *o, 662struct diff_filespec *a, 663struct diff_filespec *b) 664{ 665 entry->processed =0; 666 entry->stages[1].mode = o->mode; 667 entry->stages[2].mode = a->mode; 668 entry->stages[3].mode = b->mode; 669oidcpy(&entry->stages[1].oid, &o->oid); 670oidcpy(&entry->stages[2].oid, &a->oid); 671oidcpy(&entry->stages[3].oid, &b->oid); 672} 673 674static intremove_file(struct merge_options *opt,int clean, 675const char*path,int no_wd) 676{ 677int update_cache = opt->call_depth || clean; 678int update_working_directory = !opt->call_depth && !no_wd; 679 680if(update_cache) { 681if(remove_file_from_index(opt->repo->index, path)) 682return-1; 683} 684if(update_working_directory) { 685if(ignore_case) { 686struct cache_entry *ce; 687 ce =index_file_exists(opt->repo->index, path,strlen(path), 688 ignore_case); 689if(ce &&ce_stage(ce) ==0&&strcmp(path, ce->name)) 690return0; 691} 692if(remove_path(path)) 693return-1; 694} 695return0; 696} 697 698/* add a string to a strbuf, but converting "/" to "_" */ 699static voidadd_flattened_path(struct strbuf *out,const char*s) 700{ 701size_t i = out->len; 702strbuf_addstr(out, s); 703for(; i < out->len; i++) 704if(out->buf[i] =='/') 705 out->buf[i] ='_'; 706} 707 708static char*unique_path(struct merge_options *opt,const char*path,const char*branch) 709{ 710struct path_hashmap_entry *entry; 711struct strbuf newpath = STRBUF_INIT; 712int suffix =0; 713size_t base_len; 714 715strbuf_addf(&newpath,"%s~", path); 716add_flattened_path(&newpath, branch); 717 718 base_len = newpath.len; 719while(hashmap_get_from_hash(&opt->current_file_dir_set, 720path_hash(newpath.buf), newpath.buf) || 721(!opt->call_depth &&file_exists(newpath.buf))) { 722strbuf_setlen(&newpath, base_len); 723strbuf_addf(&newpath,"_%d", suffix++); 724} 725 726FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 727hashmap_entry_init(entry,path_hash(entry->path)); 728hashmap_add(&opt->current_file_dir_set, entry); 729returnstrbuf_detach(&newpath, NULL); 730} 731 732/** 733 * Check whether a directory in the index is in the way of an incoming 734 * file. Return 1 if so. If check_working_copy is non-zero, also 735 * check the working directory. If empty_ok is non-zero, also return 736 * 0 in the case where the working-tree dir exists but is empty. 737 */ 738static intdir_in_way(struct index_state *istate,const char*path, 739int check_working_copy,int empty_ok) 740{ 741int pos; 742struct strbuf dirpath = STRBUF_INIT; 743struct stat st; 744 745strbuf_addstr(&dirpath, path); 746strbuf_addch(&dirpath,'/'); 747 748 pos =index_name_pos(istate, dirpath.buf, dirpath.len); 749 750if(pos <0) 751 pos = -1- pos; 752if(pos < istate->cache_nr && 753!strncmp(dirpath.buf, istate->cache[pos]->name, dirpath.len)) { 754strbuf_release(&dirpath); 755return1; 756} 757 758strbuf_release(&dirpath); 759return check_working_copy && !lstat(path, &st) &&S_ISDIR(st.st_mode) && 760!(empty_ok &&is_empty_dir(path)); 761} 762 763/* 764 * Returns whether path was tracked in the index before the merge started, 765 * and its oid and mode match the specified values 766 */ 767static intwas_tracked_and_matches(struct merge_options *opt,const char*path, 768const struct diff_filespec *blob) 769{ 770int pos =index_name_pos(&opt->orig_index, path,strlen(path)); 771struct cache_entry *ce; 772 773if(0> pos) 774/* we were not tracking this path before the merge */ 775return0; 776 777/* See if the file we were tracking before matches */ 778 ce = opt->orig_index.cache[pos]; 779return(oid_eq(&ce->oid, &blob->oid) && ce->ce_mode == blob->mode); 780} 781 782/* 783 * Returns whether path was tracked in the index before the merge started 784 */ 785static intwas_tracked(struct merge_options *opt,const char*path) 786{ 787int pos =index_name_pos(&opt->orig_index, path,strlen(path)); 788 789if(0<= pos) 790/* we were tracking this path before the merge */ 791return1; 792 793return0; 794} 795 796static intwould_lose_untracked(struct merge_options *opt,const char*path) 797{ 798struct index_state *istate = opt->repo->index; 799 800/* 801 * This may look like it can be simplified to: 802 * return !was_tracked(opt, path) && file_exists(path) 803 * but it can't. This function needs to know whether path was in 804 * the working tree due to EITHER having been tracked in the index 805 * before the merge OR having been put into the working copy and 806 * index by unpack_trees(). Due to that either-or requirement, we 807 * check the current index instead of the original one. 808 * 809 * Note that we do not need to worry about merge-recursive itself 810 * updating the index after unpack_trees() and before calling this 811 * function, because we strictly require all code paths in 812 * merge-recursive to update the working tree first and the index 813 * second. Doing otherwise would break 814 * update_file()/would_lose_untracked(); see every comment in this 815 * file which mentions "update_stages". 816 */ 817int pos =index_name_pos(istate, path,strlen(path)); 818 819if(pos <0) 820 pos = -1- pos; 821while(pos < istate->cache_nr && 822!strcmp(path, istate->cache[pos]->name)) { 823/* 824 * If stage #0, it is definitely tracked. 825 * If it has stage #2 then it was tracked 826 * before this merge started. All other 827 * cases the path was not tracked. 828 */ 829switch(ce_stage(istate->cache[pos])) { 830case0: 831case2: 832return0; 833} 834 pos++; 835} 836returnfile_exists(path); 837} 838 839static intwas_dirty(struct merge_options *opt,const char*path) 840{ 841struct cache_entry *ce; 842int dirty =1; 843 844if(opt->call_depth || !was_tracked(opt, path)) 845return!dirty; 846 847 ce =index_file_exists(opt->unpack_opts.src_index, 848 path,strlen(path), ignore_case); 849 dirty =verify_uptodate(ce, &opt->unpack_opts) !=0; 850return dirty; 851} 852 853static intmake_room_for_path(struct merge_options *opt,const char*path) 854{ 855int status, i; 856const char*msg =_("failed to create path '%s'%s"); 857 858/* Unlink any D/F conflict files that are in the way */ 859for(i =0; i < opt->df_conflict_file_set.nr; i++) { 860const char*df_path = opt->df_conflict_file_set.items[i].string; 861size_t pathlen =strlen(path); 862size_t df_pathlen =strlen(df_path); 863if(df_pathlen < pathlen && 864 path[df_pathlen] =='/'&& 865strncmp(path, df_path, df_pathlen) ==0) { 866output(opt,3, 867_("Removing%sto make room for subdirectory\n"), 868 df_path); 869unlink(df_path); 870unsorted_string_list_delete_item(&opt->df_conflict_file_set, 871 i,0); 872break; 873} 874} 875 876/* Make sure leading directories are created */ 877 status =safe_create_leading_directories_const(path); 878if(status) { 879if(status == SCLD_EXISTS) 880/* something else exists */ 881returnerr(opt, msg, path,_(": perhaps a D/F conflict?")); 882returnerr(opt, msg, path,""); 883} 884 885/* 886 * Do not unlink a file in the work tree if we are not 887 * tracking it. 888 */ 889if(would_lose_untracked(opt, path)) 890returnerr(opt,_("refusing to lose untracked file at '%s'"), 891 path); 892 893/* Successful unlink is good.. */ 894if(!unlink(path)) 895return0; 896/* .. and so is no existing file */ 897if(errno == ENOENT) 898return0; 899/* .. but not some other error (who really cares what?) */ 900returnerr(opt, msg, path,_(": perhaps a D/F conflict?")); 901} 902 903static intupdate_file_flags(struct merge_options *opt, 904const struct diff_filespec *contents, 905const char*path, 906int update_cache, 907int update_wd) 908{ 909int ret =0; 910 911if(opt->call_depth) 912 update_wd =0; 913 914if(update_wd) { 915enum object_type type; 916void*buf; 917unsigned long size; 918 919if(S_ISGITLINK(contents->mode)) { 920/* 921 * We may later decide to recursively descend into 922 * the submodule directory and update its index 923 * and/or work tree, but we do not do that now. 924 */ 925 update_wd =0; 926goto update_index; 927} 928 929 buf =read_object_file(&contents->oid, &type, &size); 930if(!buf) 931returnerr(opt,_("cannot read object%s'%s'"), 932oid_to_hex(&contents->oid), path); 933if(type != OBJ_BLOB) { 934 ret =err(opt,_("blob expected for%s'%s'"), 935oid_to_hex(&contents->oid), path); 936goto free_buf; 937} 938if(S_ISREG(contents->mode)) { 939struct strbuf strbuf = STRBUF_INIT; 940if(convert_to_working_tree(opt->repo->index, path, buf, size, &strbuf)) { 941free(buf); 942 size = strbuf.len; 943 buf =strbuf_detach(&strbuf, NULL); 944} 945} 946 947if(make_room_for_path(opt, path) <0) { 948 update_wd =0; 949goto free_buf; 950} 951if(S_ISREG(contents->mode) || 952(!has_symlinks &&S_ISLNK(contents->mode))) { 953int fd; 954int mode = (contents->mode &0100?0777:0666); 955 956 fd =open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 957if(fd <0) { 958 ret =err(opt,_("failed to open '%s':%s"), 959 path,strerror(errno)); 960goto free_buf; 961} 962write_in_full(fd, buf, size); 963close(fd); 964}else if(S_ISLNK(contents->mode)) { 965char*lnk =xmemdupz(buf, size); 966safe_create_leading_directories_const(path); 967unlink(path); 968if(symlink(lnk, path)) 969 ret =err(opt,_("failed to symlink '%s':%s"), 970 path,strerror(errno)); 971free(lnk); 972}else 973 ret =err(opt, 974_("do not know what to do with%06o%s'%s'"), 975 contents->mode,oid_to_hex(&contents->oid), path); 976 free_buf: 977free(buf); 978} 979update_index: 980if(!ret && update_cache) 981if(add_cacheinfo(opt, contents, path,0, update_wd, 982 ADD_CACHE_OK_TO_ADD)) 983return-1; 984return ret; 985} 986 987static intupdate_file(struct merge_options *opt, 988int clean, 989const struct diff_filespec *contents, 990const char*path) 991{ 992returnupdate_file_flags(opt, contents, path, 993 opt->call_depth || clean, !opt->call_depth); 994} 995 996/* Low level file merging, update and removal */ 997 998struct merge_file_info { 999struct diff_filespec blob;/* mostly use oid & mode; sometimes path */1000unsigned clean:1,1001 merge:1;1002};10031004static intmerge_3way(struct merge_options *opt,1005 mmbuffer_t *result_buf,1006const struct diff_filespec *o,1007const struct diff_filespec *a,1008const struct diff_filespec *b,1009const char*branch1,1010const char*branch2,1011const int extra_marker_size)1012{1013 mmfile_t orig, src1, src2;1014struct ll_merge_options ll_opts = {0};1015char*base_name, *name1, *name2;1016int merge_status;10171018 ll_opts.renormalize = opt->renormalize;1019 ll_opts.extra_marker_size = extra_marker_size;1020 ll_opts.xdl_opts = opt->xdl_opts;10211022if(opt->call_depth) {1023 ll_opts.virtual_ancestor =1;1024 ll_opts.variant =0;1025}else{1026switch(opt->recursive_variant) {1027case MERGE_RECURSIVE_OURS:1028 ll_opts.variant = XDL_MERGE_FAVOR_OURS;1029break;1030case MERGE_RECURSIVE_THEIRS:1031 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;1032break;1033default:1034 ll_opts.variant =0;1035break;1036}1037}10381039assert(a->path && b->path);1040if(strcmp(a->path, b->path) ||1041(opt->ancestor != NULL &&strcmp(a->path, o->path) !=0)) {1042 base_name = opt->ancestor == NULL ? NULL :1043mkpathdup("%s:%s", opt->ancestor, o->path);1044 name1 =mkpathdup("%s:%s", branch1, a->path);1045 name2 =mkpathdup("%s:%s", branch2, b->path);1046}else{1047 base_name = opt->ancestor == NULL ? NULL :1048mkpathdup("%s", opt->ancestor);1049 name1 =mkpathdup("%s", branch1);1050 name2 =mkpathdup("%s", branch2);1051}10521053read_mmblob(&orig, &o->oid);1054read_mmblob(&src1, &a->oid);1055read_mmblob(&src2, &b->oid);10561057 merge_status =ll_merge(result_buf, a->path, &orig, base_name,1058&src1, name1, &src2, name2,1059 opt->repo->index, &ll_opts);10601061free(base_name);1062free(name1);1063free(name2);1064free(orig.ptr);1065free(src1.ptr);1066free(src2.ptr);1067return merge_status;1068}10691070static intfind_first_merges(struct repository *repo,1071struct object_array *result,const char*path,1072struct commit *a,struct commit *b)1073{1074int i, j;1075struct object_array merges = OBJECT_ARRAY_INIT;1076struct commit *commit;1077int contains_another;10781079char merged_revision[42];1080const char*rev_args[] = {"rev-list","--merges","--ancestry-path",1081"--all", merged_revision, NULL };1082struct rev_info revs;1083struct setup_revision_opt rev_opts;10841085memset(result,0,sizeof(struct object_array));1086memset(&rev_opts,0,sizeof(rev_opts));10871088/* get all revisions that merge commit a */1089xsnprintf(merged_revision,sizeof(merged_revision),"^%s",1090oid_to_hex(&a->object.oid));1091repo_init_revisions(repo, &revs, NULL);1092 rev_opts.submodule = path;1093/* FIXME: can't handle linked worktrees in submodules yet */1094 revs.single_worktree = path != NULL;1095setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);10961097/* save all revisions from the above list that contain b */1098if(prepare_revision_walk(&revs))1099die("revision walk setup failed");1100while((commit =get_revision(&revs)) != NULL) {1101struct object *o = &(commit->object);1102if(in_merge_bases(b, commit))1103add_object_array(o, NULL, &merges);1104}1105reset_revision_walk();11061107/* Now we've got all merges that contain a and b. Prune all1108 * merges that contain another found merge and save them in1109 * result.1110 */1111for(i =0; i < merges.nr; i++) {1112struct commit *m1 = (struct commit *) merges.objects[i].item;11131114 contains_another =0;1115for(j =0; j < merges.nr; j++) {1116struct commit *m2 = (struct commit *) merges.objects[j].item;1117if(i != j &&in_merge_bases(m2, m1)) {1118 contains_another =1;1119break;1120}1121}11221123if(!contains_another)1124add_object_array(merges.objects[i].item, NULL, result);1125}11261127object_array_clear(&merges);1128return result->nr;1129}11301131static voidprint_commit(struct commit *commit)1132{1133struct strbuf sb = STRBUF_INIT;1134struct pretty_print_context ctx = {0};1135 ctx.date_mode.type = DATE_NORMAL;1136format_commit_message(commit,"%h:%m %s", &sb, &ctx);1137fprintf(stderr,"%s\n", sb.buf);1138strbuf_release(&sb);1139}11401141static intis_valid(const struct diff_filespec *dfs)1142{1143return dfs->mode !=0&& !is_null_oid(&dfs->oid);1144}11451146static intmerge_submodule(struct merge_options *opt,1147struct object_id *result,const char*path,1148const struct object_id *base,const struct object_id *a,1149const struct object_id *b)1150{1151struct commit *commit_base, *commit_a, *commit_b;1152int parent_count;1153struct object_array merges;11541155int i;1156int search = !opt->call_depth;11571158/* store a in result in case we fail */1159oidcpy(result, a);11601161/* we can not handle deletion conflicts */1162if(is_null_oid(base))1163return0;1164if(is_null_oid(a))1165return0;1166if(is_null_oid(b))1167return0;11681169if(add_submodule_odb(path)) {1170output(opt,1,_("Failed to merge submodule%s(not checked out)"), path);1171return0;1172}11731174if(!(commit_base =lookup_commit_reference(opt->repo, base)) ||1175!(commit_a =lookup_commit_reference(opt->repo, a)) ||1176!(commit_b =lookup_commit_reference(opt->repo, b))) {1177output(opt,1,_("Failed to merge submodule%s(commits not present)"), path);1178return0;1179}11801181/* check whether both changes are forward */1182if(!in_merge_bases(commit_base, commit_a) ||1183!in_merge_bases(commit_base, commit_b)) {1184output(opt,1,_("Failed to merge submodule%s(commits don't follow merge-base)"), path);1185return0;1186}11871188/* Case #1: a is contained in b or vice versa */1189if(in_merge_bases(commit_a, commit_b)) {1190oidcpy(result, b);1191if(show(opt,3)) {1192output(opt,3,_("Fast-forwarding submodule%sto the following commit:"), path);1193output_commit_title(opt, commit_b);1194}else if(show(opt,2))1195output(opt,2,_("Fast-forwarding submodule%s"), path);1196else1197;/* no output */11981199return1;1200}1201if(in_merge_bases(commit_b, commit_a)) {1202oidcpy(result, a);1203if(show(opt,3)) {1204output(opt,3,_("Fast-forwarding submodule%sto the following commit:"), path);1205output_commit_title(opt, commit_a);1206}else if(show(opt,2))1207output(opt,2,_("Fast-forwarding submodule%s"), path);1208else1209;/* no output */12101211return1;1212}12131214/*1215 * Case #2: There are one or more merges that contain a and b in1216 * the submodule. If there is only one, then present it as a1217 * suggestion to the user, but leave it marked unmerged so the1218 * user needs to confirm the resolution.1219 */12201221/* Skip the search if makes no sense to the calling context. */1222if(!search)1223return0;12241225/* find commit which merges them */1226 parent_count =find_first_merges(opt->repo, &merges, path,1227 commit_a, commit_b);1228switch(parent_count) {1229case0:1230output(opt,1,_("Failed to merge submodule%s(merge following commits not found)"), path);1231break;12321233case1:1234output(opt,1,_("Failed to merge submodule%s(not fast-forward)"), path);1235output(opt,2,_("Found a possible merge resolution for the submodule:\n"));1236print_commit((struct commit *) merges.objects[0].item);1237output(opt,2,_(1238"If this is correct simply add it to the index "1239"for example\n"1240"by using:\n\n"1241" git update-index --cacheinfo 160000%s\"%s\"\n\n"1242"which will accept this suggestion.\n"),1243oid_to_hex(&merges.objects[0].item->oid), path);1244break;12451246default:1247output(opt,1,_("Failed to merge submodule%s(multiple merges found)"), path);1248for(i =0; i < merges.nr; i++)1249print_commit((struct commit *) merges.objects[i].item);1250}12511252object_array_clear(&merges);1253return0;1254}12551256static intmerge_mode_and_contents(struct merge_options *opt,1257const struct diff_filespec *o,1258const struct diff_filespec *a,1259const struct diff_filespec *b,1260const char*filename,1261const char*branch1,1262const char*branch2,1263const int extra_marker_size,1264struct merge_file_info *result)1265{1266if(opt->branch1 != branch1) {1267/*1268 * It's weird getting a reverse merge with HEAD on the bottom1269 * side of the conflict markers and the other branch on the1270 * top. Fix that.1271 */1272returnmerge_mode_and_contents(opt, o, b, a,1273 filename,1274 branch2, branch1,1275 extra_marker_size, result);1276}12771278 result->merge =0;1279 result->clean =1;12801281if((S_IFMT & a->mode) != (S_IFMT & b->mode)) {1282 result->clean =0;1283if(S_ISREG(a->mode)) {1284 result->blob.mode = a->mode;1285oidcpy(&result->blob.oid, &a->oid);1286}else{1287 result->blob.mode = b->mode;1288oidcpy(&result->blob.oid, &b->oid);1289}1290}else{1291if(!oid_eq(&a->oid, &o->oid) && !oid_eq(&b->oid, &o->oid))1292 result->merge =1;12931294/*1295 * Merge modes1296 */1297if(a->mode == b->mode || a->mode == o->mode)1298 result->blob.mode = b->mode;1299else{1300 result->blob.mode = a->mode;1301if(b->mode != o->mode) {1302 result->clean =0;1303 result->merge =1;1304}1305}13061307if(oid_eq(&a->oid, &b->oid) ||oid_eq(&a->oid, &o->oid))1308oidcpy(&result->blob.oid, &b->oid);1309else if(oid_eq(&b->oid, &o->oid))1310oidcpy(&result->blob.oid, &a->oid);1311else if(S_ISREG(a->mode)) {1312 mmbuffer_t result_buf;1313int ret =0, merge_status;13141315 merge_status =merge_3way(opt, &result_buf, o, a, b,1316 branch1, branch2,1317 extra_marker_size);13181319if((merge_status <0) || !result_buf.ptr)1320 ret =err(opt,_("Failed to execute internal merge"));13211322if(!ret &&1323write_object_file(result_buf.ptr, result_buf.size,1324 blob_type, &result->blob.oid))1325 ret =err(opt,_("Unable to add%sto database"),1326 a->path);13271328free(result_buf.ptr);1329if(ret)1330return ret;1331 result->clean = (merge_status ==0);1332}else if(S_ISGITLINK(a->mode)) {1333 result->clean =merge_submodule(opt, &result->blob.oid,1334 o->path,1335&o->oid,1336&a->oid,1337&b->oid);1338}else if(S_ISLNK(a->mode)) {1339switch(opt->recursive_variant) {1340case MERGE_RECURSIVE_NORMAL:1341oidcpy(&result->blob.oid, &a->oid);1342if(!oid_eq(&a->oid, &b->oid))1343 result->clean =0;1344break;1345case MERGE_RECURSIVE_OURS:1346oidcpy(&result->blob.oid, &a->oid);1347break;1348case MERGE_RECURSIVE_THEIRS:1349oidcpy(&result->blob.oid, &b->oid);1350break;1351}1352}else1353BUG("unsupported object type in the tree");1354}13551356if(result->merge)1357output(opt,2,_("Auto-merging%s"), filename);13581359return0;1360}13611362static inthandle_rename_via_dir(struct merge_options *opt,1363struct rename_conflict_info *ci)1364{1365/*1366 * Handle file adds that need to be renamed due to directory rename1367 * detection. This differs from handle_rename_normal, because1368 * there is no content merge to do; just move the file into the1369 * desired final location.1370 */1371const struct rename *ren = ci->ren1;1372const struct diff_filespec *dest = ren->pair->two;1373char*file_path = dest->path;1374int mark_conflicted = (opt->detect_directory_renames ==1);1375assert(ren->dir_rename_original_dest);13761377if(!opt->call_depth &&would_lose_untracked(opt, dest->path)) {1378 mark_conflicted =1;1379 file_path =unique_path(opt, dest->path, ren->branch);1380output(opt,1,_("Error: Refusing to lose untracked file at%s; "1381"writing to%sinstead."),1382 dest->path, file_path);1383}13841385if(mark_conflicted) {1386/*1387 * Write the file in worktree at file_path. In the index,1388 * only record the file at dest->path in the appropriate1389 * higher stage.1390 */1391if(update_file(opt,0, dest, file_path))1392return-1;1393if(file_path != dest->path)1394free(file_path);1395if(update_stages(opt, dest->path, NULL,1396 ren->branch == opt->branch1 ? dest : NULL,1397 ren->branch == opt->branch1 ? NULL : dest))1398return-1;1399return0;/* not clean, but conflicted */1400}else{1401/* Update dest->path both in index and in worktree */1402if(update_file(opt,1, dest, dest->path))1403return-1;1404return1;/* clean */1405}1406}14071408static inthandle_change_delete(struct merge_options *opt,1409const char*path,const char*old_path,1410const struct diff_filespec *o,1411const struct diff_filespec *changed,1412const char*change_branch,1413const char*delete_branch,1414const char*change,const char*change_past)1415{1416char*alt_path = NULL;1417const char*update_path = path;1418int ret =0;14191420if(dir_in_way(opt->repo->index, path, !opt->call_depth,0) ||1421(!opt->call_depth &&would_lose_untracked(opt, path))) {1422 update_path = alt_path =unique_path(opt, path, change_branch);1423}14241425if(opt->call_depth) {1426/*1427 * We cannot arbitrarily accept either a_sha or b_sha as1428 * correct; since there is no true "middle point" between1429 * them, simply reuse the base version for virtual merge base.1430 */1431 ret =remove_file_from_index(opt->repo->index, path);1432if(!ret)1433 ret =update_file(opt,0, o, update_path);1434}else{1435/*1436 * Despite the four nearly duplicate messages and argument1437 * lists below and the ugliness of the nested if-statements,1438 * having complete messages makes the job easier for1439 * translators.1440 *1441 * The slight variance among the cases is due to the fact1442 * that:1443 * 1) directory/file conflicts (in effect if1444 * !alt_path) could cause us to need to write the1445 * file to a different path.1446 * 2) renames (in effect if !old_path) could mean that1447 * there are two names for the path that the user1448 * may know the file by.1449 */1450if(!alt_path) {1451if(!old_path) {1452output(opt,1,_("CONFLICT (%s/delete):%sdeleted in%s"1453"and%sin%s. Version%sof%sleft in tree."),1454 change, path, delete_branch, change_past,1455 change_branch, change_branch, path);1456}else{1457output(opt,1,_("CONFLICT (%s/delete):%sdeleted in%s"1458"and%sto%sin%s. Version%sof%sleft in tree."),1459 change, old_path, delete_branch, change_past, path,1460 change_branch, change_branch, path);1461}1462}else{1463if(!old_path) {1464output(opt,1,_("CONFLICT (%s/delete):%sdeleted in%s"1465"and%sin%s. Version%sof%sleft in tree at%s."),1466 change, path, delete_branch, change_past,1467 change_branch, change_branch, path, alt_path);1468}else{1469output(opt,1,_("CONFLICT (%s/delete):%sdeleted in%s"1470"and%sto%sin%s. Version%sof%sleft in tree at%s."),1471 change, old_path, delete_branch, change_past, path,1472 change_branch, change_branch, path, alt_path);1473}1474}1475/*1476 * No need to call update_file() on path when change_branch ==1477 * opt->branch1 && !alt_path, since that would needlessly touch1478 * path. We could call update_file_flags() with update_cache=01479 * and update_wd=0, but that's a no-op.1480 */1481if(change_branch != opt->branch1 || alt_path)1482 ret =update_file(opt,0, changed, update_path);1483}1484free(alt_path);14851486return ret;1487}14881489static inthandle_rename_delete(struct merge_options *opt,1490struct rename_conflict_info *ci)1491{1492const struct rename *ren = ci->ren1;1493const struct diff_filespec *orig = ren->pair->one;1494const struct diff_filespec *dest = ren->pair->two;1495const char*rename_branch = ren->branch;1496const char*delete_branch = (opt->branch1 == ren->branch ?1497 opt->branch2 : opt->branch1);14981499if(handle_change_delete(opt,1500 opt->call_depth ? orig->path : dest->path,1501 opt->call_depth ? NULL : orig->path,1502 orig, dest,1503 rename_branch, delete_branch,1504_("rename"),_("renamed")))1505return-1;15061507if(opt->call_depth)1508returnremove_file_from_index(opt->repo->index, dest->path);1509else1510returnupdate_stages(opt, dest->path, NULL,1511 rename_branch == opt->branch1 ? dest : NULL,1512 rename_branch == opt->branch1 ? NULL : dest);1513}15141515static inthandle_file_collision(struct merge_options *opt,1516const char*collide_path,1517const char*prev_path1,1518const char*prev_path2,1519const char*branch1,const char*branch2,1520struct diff_filespec *a,1521struct diff_filespec *b)1522{1523struct merge_file_info mfi;1524struct diff_filespec null;1525char*alt_path = NULL;1526const char*update_path = collide_path;15271528/*1529 * It's easiest to get the correct things into stage 2 and 3, and1530 * to make sure that the content merge puts HEAD before the other1531 * branch if we just ensure that branch1 == opt->branch1. So, simply1532 * flip arguments around if we don't have that.1533 */1534if(branch1 != opt->branch1) {1535returnhandle_file_collision(opt, collide_path,1536 prev_path2, prev_path1,1537 branch2, branch1,1538 b, a);1539}15401541/*1542 * In the recursive case, we just opt to undo renames1543 */1544if(opt->call_depth && (prev_path1 || prev_path2)) {1545/* Put first file (a->oid, a->mode) in its original spot */1546if(prev_path1) {1547if(update_file(opt,1, a, prev_path1))1548return-1;1549}else{1550if(update_file(opt,1, a, collide_path))1551return-1;1552}15531554/* Put second file (b->oid, b->mode) in its original spot */1555if(prev_path2) {1556if(update_file(opt,1, b, prev_path2))1557return-1;1558}else{1559if(update_file(opt,1, b, collide_path))1560return-1;1561}15621563/* Don't leave something at collision path if unrenaming both */1564if(prev_path1 && prev_path2)1565remove_file(opt,1, collide_path,0);15661567return0;1568}15691570/* Remove rename sources if rename/add or rename/rename(2to1) */1571if(prev_path1)1572remove_file(opt,1, prev_path1,1573 opt->call_depth ||would_lose_untracked(opt, prev_path1));1574if(prev_path2)1575remove_file(opt,1, prev_path2,1576 opt->call_depth ||would_lose_untracked(opt, prev_path2));15771578/*1579 * Remove the collision path, if it wouldn't cause dirty contents1580 * or an untracked file to get lost. We'll either overwrite with1581 * merged contents, or just write out to differently named files.1582 */1583if(was_dirty(opt, collide_path)) {1584output(opt,1,_("Refusing to lose dirty file at%s"),1585 collide_path);1586 update_path = alt_path =unique_path(opt, collide_path,"merged");1587}else if(would_lose_untracked(opt, collide_path)) {1588/*1589 * Only way we get here is if both renames were from1590 * a directory rename AND user had an untracked file1591 * at the location where both files end up after the1592 * two directory renames. See testcase 10d of t6043.1593 */1594output(opt,1,_("Refusing to lose untracked file at "1595"%s, even though it's in the way."),1596 collide_path);1597 update_path = alt_path =unique_path(opt, collide_path,"merged");1598}else{1599/*1600 * FIXME: It's possible that the two files are identical1601 * and that the current working copy happens to match, in1602 * which case we are unnecessarily touching the working1603 * tree file. It's not a likely enough scenario that I1604 * want to code up the checks for it and a better fix is1605 * available if we restructure how unpack_trees() and1606 * merge-recursive interoperate anyway, so punting for1607 * now...1608 */1609remove_file(opt,0, collide_path,0);1610}16111612/* Store things in diff_filespecs for functions that need it */1613 null.path = (char*)collide_path;1614oidcpy(&null.oid, &null_oid);1615 null.mode =0;16161617if(merge_mode_and_contents(opt, &null, a, b, collide_path,1618 branch1, branch2, opt->call_depth *2, &mfi))1619return-1;1620 mfi.clean &= !alt_path;1621if(update_file(opt, mfi.clean, &mfi.blob, update_path))1622return-1;1623if(!mfi.clean && !opt->call_depth &&1624update_stages(opt, collide_path, NULL, a, b))1625return-1;1626free(alt_path);1627/*1628 * FIXME: If both a & b both started with conflicts (only possible1629 * if they came from a rename/rename(2to1)), but had IDENTICAL1630 * contents including those conflicts, then in the next line we claim1631 * it was clean. If someone cares about this case, we should have the1632 * caller notify us if we started with conflicts.1633 */1634return mfi.clean;1635}16361637static inthandle_rename_add(struct merge_options *opt,1638struct rename_conflict_info *ci)1639{1640/* a was renamed to c, and a separate c was added. */1641struct diff_filespec *a = ci->ren1->pair->one;1642struct diff_filespec *c = ci->ren1->pair->two;1643char*path = c->path;1644char*prev_path_desc;1645struct merge_file_info mfi;16461647const char*rename_branch = ci->ren1->branch;1648const char*add_branch = (opt->branch1 == rename_branch ?1649 opt->branch2 : opt->branch1);1650int other_stage = (ci->ren1->branch == opt->branch1 ?3:2);16511652output(opt,1,_("CONFLICT (rename/add): "1653"Rename%s->%sin%s. Added%sin%s"),1654 a->path, c->path, rename_branch,1655 c->path, add_branch);16561657 prev_path_desc =xstrfmt("version of%sfrom%s", path, a->path);1658 ci->ren1->src_entry->stages[other_stage].path = a->path;1659if(merge_mode_and_contents(opt, a, c,1660&ci->ren1->src_entry->stages[other_stage],1661 prev_path_desc,1662 opt->branch1, opt->branch2,16631+ opt->call_depth *2, &mfi))1664return-1;1665free(prev_path_desc);16661667 ci->ren1->dst_entry->stages[other_stage].path = mfi.blob.path = c->path;1668returnhandle_file_collision(opt,1669 c->path, a->path, NULL,1670 rename_branch, add_branch,1671&mfi.blob,1672&ci->ren1->dst_entry->stages[other_stage]);1673}16741675static char*find_path_for_conflict(struct merge_options *opt,1676const char*path,1677const char*branch1,1678const char*branch2)1679{1680char*new_path = NULL;1681if(dir_in_way(opt->repo->index, path, !opt->call_depth,0)) {1682 new_path =unique_path(opt, path, branch1);1683output(opt,1,_("%sis a directory in%sadding "1684"as%sinstead"),1685 path, branch2, new_path);1686}else if(would_lose_untracked(opt, path)) {1687 new_path =unique_path(opt, path, branch1);1688output(opt,1,_("Refusing to lose untracked file"1689" at%s; adding as%sinstead"),1690 path, new_path);1691}16921693return new_path;1694}16951696static inthandle_rename_rename_1to2(struct merge_options *opt,1697struct rename_conflict_info *ci)1698{1699/* One file was renamed in both branches, but to different names. */1700struct merge_file_info mfi;1701struct diff_filespec *add;1702struct diff_filespec *o = ci->ren1->pair->one;1703struct diff_filespec *a = ci->ren1->pair->two;1704struct diff_filespec *b = ci->ren2->pair->two;1705char*path_desc;17061707output(opt,1,_("CONFLICT (rename/rename): "1708"Rename\"%s\"->\"%s\"in branch\"%s\""1709"rename\"%s\"->\"%s\"in\"%s\"%s"),1710 o->path, a->path, ci->ren1->branch,1711 o->path, b->path, ci->ren2->branch,1712 opt->call_depth ?_(" (left unresolved)") :"");17131714 path_desc =xstrfmt("%sand%s, both renamed from%s",1715 a->path, b->path, o->path);1716if(merge_mode_and_contents(opt, o, a, b, path_desc,1717 ci->ren1->branch, ci->ren2->branch,1718 opt->call_depth *2, &mfi))1719return-1;1720free(path_desc);17211722if(opt->call_depth) {1723/*1724 * FIXME: For rename/add-source conflicts (if we could detect1725 * such), this is wrong. We should instead find a unique1726 * pathname and then either rename the add-source file to that1727 * unique path, or use that unique path instead of src here.1728 */1729if(update_file(opt,0, &mfi.blob, o->path))1730return-1;17311732/*1733 * Above, we put the merged content at the merge-base's1734 * path. Now we usually need to delete both a->path and1735 * b->path. However, the rename on each side of the merge1736 * could also be involved in a rename/add conflict. In1737 * such cases, we should keep the added file around,1738 * resolving the conflict at that path in its favor.1739 */1740 add = &ci->ren1->dst_entry->stages[2^1];1741if(is_valid(add)) {1742if(update_file(opt,0, add, a->path))1743return-1;1744}1745else1746remove_file_from_index(opt->repo->index, a->path);1747 add = &ci->ren2->dst_entry->stages[3^1];1748if(is_valid(add)) {1749if(update_file(opt,0, add, b->path))1750return-1;1751}1752else1753remove_file_from_index(opt->repo->index, b->path);1754}else{1755/*1756 * For each destination path, we need to see if there is a1757 * rename/add collision. If not, we can write the file out1758 * to the specified location.1759 */1760 add = &ci->ren1->dst_entry->stages[2^1];1761if(is_valid(add)) {1762 add->path = mfi.blob.path = a->path;1763if(handle_file_collision(opt, a->path,1764 NULL, NULL,1765 ci->ren1->branch,1766 ci->ren2->branch,1767&mfi.blob, add) <0)1768return-1;1769}else{1770char*new_path =find_path_for_conflict(opt, a->path,1771 ci->ren1->branch,1772 ci->ren2->branch);1773if(update_file(opt,0, &mfi.blob,1774 new_path ? new_path : a->path))1775return-1;1776free(new_path);1777if(update_stages(opt, a->path, NULL, a, NULL))1778return-1;1779}17801781 add = &ci->ren2->dst_entry->stages[3^1];1782if(is_valid(add)) {1783 add->path = mfi.blob.path = b->path;1784if(handle_file_collision(opt, b->path,1785 NULL, NULL,1786 ci->ren1->branch,1787 ci->ren2->branch,1788 add, &mfi.blob) <0)1789return-1;1790}else{1791char*new_path =find_path_for_conflict(opt, b->path,1792 ci->ren2->branch,1793 ci->ren1->branch);1794if(update_file(opt,0, &mfi.blob,1795 new_path ? new_path : b->path))1796return-1;1797free(new_path);1798if(update_stages(opt, b->path, NULL, NULL, b))1799return-1;1800}1801}18021803return0;1804}18051806static inthandle_rename_rename_2to1(struct merge_options *opt,1807struct rename_conflict_info *ci)1808{1809/* Two files, a & b, were renamed to the same thing, c. */1810struct diff_filespec *a = ci->ren1->pair->one;1811struct diff_filespec *b = ci->ren2->pair->one;1812struct diff_filespec *c1 = ci->ren1->pair->two;1813struct diff_filespec *c2 = ci->ren2->pair->two;1814char*path = c1->path;/* == c2->path */1815char*path_side_1_desc;1816char*path_side_2_desc;1817struct merge_file_info mfi_c1;1818struct merge_file_info mfi_c2;1819int ostage1, ostage2;18201821output(opt,1,_("CONFLICT (rename/rename): "1822"Rename%s->%sin%s. "1823"Rename%s->%sin%s"),1824 a->path, c1->path, ci->ren1->branch,1825 b->path, c2->path, ci->ren2->branch);18261827 path_side_1_desc =xstrfmt("version of%sfrom%s", path, a->path);1828 path_side_2_desc =xstrfmt("version of%sfrom%s", path, b->path);1829 ostage1 = ci->ren1->branch == opt->branch1 ?3:2;1830 ostage2 = ostage1 ^1;1831 ci->ren1->src_entry->stages[ostage1].path = a->path;1832 ci->ren2->src_entry->stages[ostage2].path = b->path;1833if(merge_mode_and_contents(opt, a, c1,1834&ci->ren1->src_entry->stages[ostage1],1835 path_side_1_desc,1836 opt->branch1, opt->branch2,18371+ opt->call_depth *2, &mfi_c1) ||1838merge_mode_and_contents(opt, b,1839&ci->ren2->src_entry->stages[ostage2],1840 c2, path_side_2_desc,1841 opt->branch1, opt->branch2,18421+ opt->call_depth *2, &mfi_c2))1843return-1;1844free(path_side_1_desc);1845free(path_side_2_desc);1846 mfi_c1.blob.path = path;1847 mfi_c2.blob.path = path;18481849returnhandle_file_collision(opt, path, a->path, b->path,1850 ci->ren1->branch, ci->ren2->branch,1851&mfi_c1.blob, &mfi_c2.blob);1852}18531854/*1855 * Get the diff_filepairs changed between o_tree and tree.1856 */1857static struct diff_queue_struct *get_diffpairs(struct merge_options *opt,1858struct tree *o_tree,1859struct tree *tree)1860{1861struct diff_queue_struct *ret;1862struct diff_options opts;18631864repo_diff_setup(opt->repo, &opts);1865 opts.flags.recursive =1;1866 opts.flags.rename_empty =0;1867 opts.detect_rename =merge_detect_rename(opt);1868/*1869 * We do not have logic to handle the detection of copies. In1870 * fact, it may not even make sense to add such logic: would we1871 * really want a change to a base file to be propagated through1872 * multiple other files by a merge?1873 */1874if(opts.detect_rename > DIFF_DETECT_RENAME)1875 opts.detect_rename = DIFF_DETECT_RENAME;1876 opts.rename_limit = opt->merge_rename_limit >=0? opt->merge_rename_limit :1877 opt->diff_rename_limit >=0? opt->diff_rename_limit :18781000;1879 opts.rename_score = opt->rename_score;1880 opts.show_rename_progress = opt->show_rename_progress;1881 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1882diff_setup_done(&opts);1883diff_tree_oid(&o_tree->object.oid, &tree->object.oid,"", &opts);1884diffcore_std(&opts);1885if(opts.needed_rename_limit > opt->needed_rename_limit)1886 opt->needed_rename_limit = opts.needed_rename_limit;18871888 ret =xmalloc(sizeof(*ret));1889*ret = diff_queued_diff;18901891 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1892 diff_queued_diff.nr =0;1893 diff_queued_diff.queue = NULL;1894diff_flush(&opts);1895return ret;1896}18971898static inttree_has_path(struct tree *tree,const char*path)1899{1900struct object_id hashy;1901unsigned short mode_o;19021903return!get_tree_entry(&tree->object.oid, path,1904&hashy, &mode_o);1905}19061907/*1908 * Return a new string that replaces the beginning portion (which matches1909 * entry->dir), with entry->new_dir. In perl-speak:1910 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1911 * NOTE:1912 * Caller must ensure that old_path starts with entry->dir + '/'.1913 */1914static char*apply_dir_rename(struct dir_rename_entry *entry,1915const char*old_path)1916{1917struct strbuf new_path = STRBUF_INIT;1918int oldlen, newlen;19191920if(entry->non_unique_new_dir)1921return NULL;19221923 oldlen =strlen(entry->dir);1924 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) +1;1925strbuf_grow(&new_path, newlen);1926strbuf_addbuf(&new_path, &entry->new_dir);1927strbuf_addstr(&new_path, &old_path[oldlen]);19281929returnstrbuf_detach(&new_path, NULL);1930}19311932static voidget_renamed_dir_portion(const char*old_path,const char*new_path,1933char**old_dir,char**new_dir)1934{1935char*end_of_old, *end_of_new;1936int old_len, new_len;19371938*old_dir = NULL;1939*new_dir = NULL;19401941/*1942 * For1943 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1944 * the "e/foo.c" part is the same, we just want to know that1945 * "a/b/c/d" was renamed to "a/b/some/thing/else"1946 * so, for this example, this function returns "a/b/c/d" in1947 * *old_dir and "a/b/some/thing/else" in *new_dir.1948 *1949 * Also, if the basename of the file changed, we don't care. We1950 * want to know which portion of the directory, if any, changed.1951 */1952 end_of_old =strrchr(old_path,'/');1953 end_of_new =strrchr(new_path,'/');19541955if(end_of_old == NULL || end_of_new == NULL)1956return;1957while(*--end_of_new == *--end_of_old &&1958 end_of_old != old_path &&1959 end_of_new != new_path)1960;/* Do nothing; all in the while loop */1961/*1962 * We've found the first non-matching character in the directory1963 * paths. That means the current directory we were comparing1964 * represents the rename. Move end_of_old and end_of_new back1965 * to the full directory name.1966 */1967if(*end_of_old =='/')1968 end_of_old++;1969if(*end_of_old !='/')1970 end_of_new++;1971 end_of_old =strchr(end_of_old,'/');1972 end_of_new =strchr(end_of_new,'/');19731974/*1975 * It may have been the case that old_path and new_path were the same1976 * directory all along. Don't claim a rename if they're the same.1977 */1978 old_len = end_of_old - old_path;1979 new_len = end_of_new - new_path;19801981if(old_len != new_len ||strncmp(old_path, new_path, old_len)) {1982*old_dir =xstrndup(old_path, old_len);1983*new_dir =xstrndup(new_path, new_len);1984}1985}19861987static voidremove_hashmap_entries(struct hashmap *dir_renames,1988struct string_list *items_to_remove)1989{1990int i;1991struct dir_rename_entry *entry;19921993for(i =0; i < items_to_remove->nr; i++) {1994 entry = items_to_remove->items[i].util;1995hashmap_remove(dir_renames, entry, NULL);1996}1997string_list_clear(items_to_remove,0);1998}19992000/*2001 * See if there is a directory rename for path, and if there are any file2002 * level conflicts for the renamed location. If there is a rename and2003 * there are no conflicts, return the new name. Otherwise, return NULL.2004 */2005static char*handle_path_level_conflicts(struct merge_options *opt,2006const char*path,2007struct dir_rename_entry *entry,2008struct hashmap *collisions,2009struct tree *tree)2010{2011char*new_path = NULL;2012struct collision_entry *collision_ent;2013int clean =1;2014struct strbuf collision_paths = STRBUF_INIT;20152016/*2017 * entry has the mapping of old directory name to new directory name2018 * that we want to apply to path.2019 */2020 new_path =apply_dir_rename(entry, path);20212022if(!new_path) {2023/* This should only happen when entry->non_unique_new_dir set */2024if(!entry->non_unique_new_dir)2025BUG("entry->non_unqiue_dir not set and !new_path");2026output(opt,1,_("CONFLICT (directory rename split): "2027"Unclear where to place%sbecause directory "2028"%swas renamed to multiple other directories, "2029"with no destination getting a majority of the "2030"files."),2031 path, entry->dir);2032 clean =0;2033return NULL;2034}20352036/*2037 * The caller needs to have ensured that it has pre-populated2038 * collisions with all paths that map to new_path. Do a quick check2039 * to ensure that's the case.2040 */2041 collision_ent =collision_find_entry(collisions, new_path);2042if(collision_ent == NULL)2043BUG("collision_ent is NULL");20442045/*2046 * Check for one-sided add/add/.../add conflicts, i.e.2047 * where implicit renames from the other side doing2048 * directory rename(s) can affect this side of history2049 * to put multiple paths into the same location. Warn2050 * and bail on directory renames for such paths.2051 */2052if(collision_ent->reported_already) {2053 clean =0;2054}else if(tree_has_path(tree, new_path)) {2055 collision_ent->reported_already =1;2056strbuf_add_separated_string_list(&collision_paths,", ",2057&collision_ent->source_files);2058output(opt,1,_("CONFLICT (implicit dir rename): Existing "2059"file/dir at%sin the way of implicit "2060"directory rename(s) putting the following "2061"path(s) there:%s."),2062 new_path, collision_paths.buf);2063 clean =0;2064}else if(collision_ent->source_files.nr >1) {2065 collision_ent->reported_already =1;2066strbuf_add_separated_string_list(&collision_paths,", ",2067&collision_ent->source_files);2068output(opt,1,_("CONFLICT (implicit dir rename): Cannot map "2069"more than one path to%s; implicit directory "2070"renames tried to put these paths there:%s"),2071 new_path, collision_paths.buf);2072 clean =0;2073}20742075/* Free memory we no longer need */2076strbuf_release(&collision_paths);2077if(!clean && new_path) {2078free(new_path);2079return NULL;2080}20812082return new_path;2083}20842085/*2086 * There are a couple things we want to do at the directory level:2087 * 1. Check for both sides renaming to the same thing, in order to avoid2088 * implicit renaming of files that should be left in place. (See2089 * testcase 6b in t6043 for details.)2090 * 2. Prune directory renames if there are still files left in the2091 * the original directory. These represent a partial directory rename,2092 * i.e. a rename where only some of the files within the directory2093 * were renamed elsewhere. (Technically, this could be done earlier2094 * in get_directory_renames(), except that would prevent us from2095 * doing the previous check and thus failing testcase 6b.)2096 * 3. Check for rename/rename(1to2) conflicts (at the directory level).2097 * In the future, we could potentially record this info as well and2098 * omit reporting rename/rename(1to2) conflicts for each path within2099 * the affected directories, thus cleaning up the merge output.2100 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the2101 * directory level, because merging directories is fine. If it2102 * causes conflicts for files within those merged directories, then2103 * that should be detected at the individual path level.2104 */2105static voidhandle_directory_level_conflicts(struct merge_options *opt,2106struct hashmap *dir_re_head,2107struct tree *head,2108struct hashmap *dir_re_merge,2109struct tree *merge)2110{2111struct hashmap_iter iter;2112struct dir_rename_entry *head_ent;2113struct dir_rename_entry *merge_ent;21142115struct string_list remove_from_head = STRING_LIST_INIT_NODUP;2116struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;21172118hashmap_iter_init(dir_re_head, &iter);2119while((head_ent =hashmap_iter_next(&iter))) {2120 merge_ent =dir_rename_find_entry(dir_re_merge, head_ent->dir);2121if(merge_ent &&2122!head_ent->non_unique_new_dir &&2123!merge_ent->non_unique_new_dir &&2124!strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {2125/* 1. Renamed identically; remove it from both sides */2126string_list_append(&remove_from_head,2127 head_ent->dir)->util = head_ent;2128strbuf_release(&head_ent->new_dir);2129string_list_append(&remove_from_merge,2130 merge_ent->dir)->util = merge_ent;2131strbuf_release(&merge_ent->new_dir);2132}else if(tree_has_path(head, head_ent->dir)) {2133/* 2. This wasn't a directory rename after all */2134string_list_append(&remove_from_head,2135 head_ent->dir)->util = head_ent;2136strbuf_release(&head_ent->new_dir);2137}2138}21392140remove_hashmap_entries(dir_re_head, &remove_from_head);2141remove_hashmap_entries(dir_re_merge, &remove_from_merge);21422143hashmap_iter_init(dir_re_merge, &iter);2144while((merge_ent =hashmap_iter_next(&iter))) {2145 head_ent =dir_rename_find_entry(dir_re_head, merge_ent->dir);2146if(tree_has_path(merge, merge_ent->dir)) {2147/* 2. This wasn't a directory rename after all */2148string_list_append(&remove_from_merge,2149 merge_ent->dir)->util = merge_ent;2150}else if(head_ent &&2151!head_ent->non_unique_new_dir &&2152!merge_ent->non_unique_new_dir) {2153/* 3. rename/rename(1to2) */2154/*2155 * We can assume it's not rename/rename(1to1) because2156 * that was case (1), already checked above. So we2157 * know that head_ent->new_dir and merge_ent->new_dir2158 * are different strings.2159 */2160output(opt,1,_("CONFLICT (rename/rename): "2161"Rename directory%s->%sin%s. "2162"Rename directory%s->%sin%s"),2163 head_ent->dir, head_ent->new_dir.buf, opt->branch1,2164 head_ent->dir, merge_ent->new_dir.buf, opt->branch2);2165string_list_append(&remove_from_head,2166 head_ent->dir)->util = head_ent;2167strbuf_release(&head_ent->new_dir);2168string_list_append(&remove_from_merge,2169 merge_ent->dir)->util = merge_ent;2170strbuf_release(&merge_ent->new_dir);2171}2172}21732174remove_hashmap_entries(dir_re_head, &remove_from_head);2175remove_hashmap_entries(dir_re_merge, &remove_from_merge);2176}21772178static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs)2179{2180struct hashmap *dir_renames;2181struct hashmap_iter iter;2182struct dir_rename_entry *entry;2183int i;21842185/*2186 * Typically, we think of a directory rename as all files from a2187 * certain directory being moved to a target directory. However,2188 * what if someone first moved two files from the original2189 * directory in one commit, and then renamed the directory2190 * somewhere else in a later commit? At merge time, we just know2191 * that files from the original directory went to two different2192 * places, and that the bulk of them ended up in the same place.2193 * We want each directory rename to represent where the bulk of the2194 * files from that directory end up; this function exists to find2195 * where the bulk of the files went.2196 *2197 * The first loop below simply iterates through the list of file2198 * renames, finding out how often each directory rename pair2199 * possibility occurs.2200 */2201 dir_renames =xmalloc(sizeof(*dir_renames));2202dir_rename_init(dir_renames);2203for(i =0; i < pairs->nr; ++i) {2204struct string_list_item *item;2205int*count;2206struct diff_filepair *pair = pairs->queue[i];2207char*old_dir, *new_dir;22082209/* File not part of directory rename if it wasn't renamed */2210if(pair->status !='R')2211continue;22122213get_renamed_dir_portion(pair->one->path, pair->two->path,2214&old_dir, &new_dir);2215if(!old_dir)2216/* Directory didn't change at all; ignore this one. */2217continue;22182219 entry =dir_rename_find_entry(dir_renames, old_dir);2220if(!entry) {2221 entry =xmalloc(sizeof(*entry));2222dir_rename_entry_init(entry, old_dir);2223hashmap_put(dir_renames, entry);2224}else{2225free(old_dir);2226}2227 item =string_list_lookup(&entry->possible_new_dirs, new_dir);2228if(!item) {2229 item =string_list_insert(&entry->possible_new_dirs,2230 new_dir);2231 item->util =xcalloc(1,sizeof(int));2232}else{2233free(new_dir);2234}2235 count = item->util;2236*count +=1;2237}22382239/*2240 * For each directory with files moved out of it, we find out which2241 * target directory received the most files so we can declare it to2242 * be the "winning" target location for the directory rename. This2243 * winner gets recorded in new_dir. If there is no winner2244 * (multiple target directories received the same number of files),2245 * we set non_unique_new_dir. Once we've determined the winner (or2246 * that there is no winner), we no longer need possible_new_dirs.2247 */2248hashmap_iter_init(dir_renames, &iter);2249while((entry =hashmap_iter_next(&iter))) {2250int max =0;2251int bad_max =0;2252char*best = NULL;22532254for(i =0; i < entry->possible_new_dirs.nr; i++) {2255int*count = entry->possible_new_dirs.items[i].util;22562257if(*count == max)2258 bad_max = max;2259else if(*count > max) {2260 max = *count;2261 best = entry->possible_new_dirs.items[i].string;2262}2263}2264if(bad_max == max)2265 entry->non_unique_new_dir =1;2266else{2267assert(entry->new_dir.len ==0);2268strbuf_addstr(&entry->new_dir, best);2269}2270/*2271 * The relevant directory sub-portion of the original full2272 * filepaths were xstrndup'ed before inserting into2273 * possible_new_dirs, and instead of manually iterating the2274 * list and free'ing each, just lie and tell2275 * possible_new_dirs that it did the strdup'ing so that it2276 * will free them for us.2277 */2278 entry->possible_new_dirs.strdup_strings =1;2279string_list_clear(&entry->possible_new_dirs,1);2280}22812282return dir_renames;2283}22842285static struct dir_rename_entry *check_dir_renamed(const char*path,2286struct hashmap *dir_renames)2287{2288char*temp =xstrdup(path);2289char*end;2290struct dir_rename_entry *entry = NULL;22912292while((end =strrchr(temp,'/'))) {2293*end ='\0';2294 entry =dir_rename_find_entry(dir_renames, temp);2295if(entry)2296break;2297}2298free(temp);2299return entry;2300}23012302static voidcompute_collisions(struct hashmap *collisions,2303struct hashmap *dir_renames,2304struct diff_queue_struct *pairs)2305{2306int i;23072308/*2309 * Multiple files can be mapped to the same path due to directory2310 * renames done by the other side of history. Since that other2311 * side of history could have merged multiple directories into one,2312 * if our side of history added the same file basename to each of2313 * those directories, then all N of them would get implicitly2314 * renamed by the directory rename detection into the same path,2315 * and we'd get an add/add/.../add conflict, and all those adds2316 * from *this* side of history. This is not representable in the2317 * index, and users aren't going to easily be able to make sense of2318 * it. So we need to provide a good warning about what's2319 * happening, and fall back to no-directory-rename detection2320 * behavior for those paths.2321 *2322 * See testcases 9e and all of section 5 from t6043 for examples.2323 */2324collision_init(collisions);23252326for(i =0; i < pairs->nr; ++i) {2327struct dir_rename_entry *dir_rename_ent;2328struct collision_entry *collision_ent;2329char*new_path;2330struct diff_filepair *pair = pairs->queue[i];23312332if(pair->status !='A'&& pair->status !='R')2333continue;2334 dir_rename_ent =check_dir_renamed(pair->two->path,2335 dir_renames);2336if(!dir_rename_ent)2337continue;23382339 new_path =apply_dir_rename(dir_rename_ent, pair->two->path);2340if(!new_path)2341/*2342 * dir_rename_ent->non_unique_new_path is true, which2343 * means there is no directory rename for us to use,2344 * which means it won't cause us any additional2345 * collisions.2346 */2347continue;2348 collision_ent =collision_find_entry(collisions, new_path);2349if(!collision_ent) {2350 collision_ent =xcalloc(1,2351sizeof(struct collision_entry));2352hashmap_entry_init(collision_ent,strhash(new_path));2353hashmap_put(collisions, collision_ent);2354 collision_ent->target_file = new_path;2355}else{2356free(new_path);2357}2358string_list_insert(&collision_ent->source_files,2359 pair->two->path);2360}2361}23622363static char*check_for_directory_rename(struct merge_options *opt,2364const char*path,2365struct tree *tree,2366struct hashmap *dir_renames,2367struct hashmap *dir_rename_exclusions,2368struct hashmap *collisions,2369int*clean_merge)2370{2371char*new_path = NULL;2372struct dir_rename_entry *entry =check_dir_renamed(path, dir_renames);2373struct dir_rename_entry *oentry = NULL;23742375if(!entry)2376return new_path;23772378/*2379 * This next part is a little weird. We do not want to do an2380 * implicit rename into a directory we renamed on our side, because2381 * that will result in a spurious rename/rename(1to2) conflict. An2382 * example:2383 * Base commit: dumbdir/afile, otherdir/bfile2384 * Side 1: smrtdir/afile, otherdir/bfile2385 * Side 2: dumbdir/afile, dumbdir/bfile2386 * Here, while working on Side 1, we could notice that otherdir was2387 * renamed/merged to dumbdir, and change the diff_filepair for2388 * otherdir/bfile into a rename into dumbdir/bfile. However, Side2389 * 2 will notice the rename from dumbdir to smrtdir, and do the2390 * transitive rename to move it from dumbdir/bfile to2391 * smrtdir/bfile. That gives us bfile in dumbdir vs being in2392 * smrtdir, a rename/rename(1to2) conflict. We really just want2393 * the file to end up in smrtdir. And the way to achieve that is2394 * to not let Side1 do the rename to dumbdir, since we know that is2395 * the source of one of our directory renames.2396 *2397 * That's why oentry and dir_rename_exclusions is here.2398 *2399 * As it turns out, this also prevents N-way transient rename2400 * confusion; See testcases 9c and 9d of t6043.2401 */2402 oentry =dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);2403if(oentry) {2404output(opt,1,_("WARNING: Avoiding applying%s->%srename "2405"to%s, because%sitself was renamed."),2406 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);2407}else{2408 new_path =handle_path_level_conflicts(opt, path, entry,2409 collisions, tree);2410*clean_merge &= (new_path != NULL);2411}24122413return new_path;2414}24152416static voidapply_directory_rename_modifications(struct merge_options *opt,2417struct diff_filepair *pair,2418char*new_path,2419struct rename *re,2420struct tree *tree,2421struct tree *o_tree,2422struct tree *a_tree,2423struct tree *b_tree,2424struct string_list *entries)2425{2426struct string_list_item *item;2427int stage = (tree == a_tree ?2:3);2428int update_wd;24292430/*2431 * In all cases where we can do directory rename detection,2432 * unpack_trees() will have read pair->two->path into the2433 * index and the working copy. We need to remove it so that2434 * we can instead place it at new_path. It is guaranteed to2435 * not be untracked (unpack_trees() would have errored out2436 * saying the file would have been overwritten), but it might2437 * be dirty, though.2438 */2439 update_wd = !was_dirty(opt, pair->two->path);2440if(!update_wd)2441output(opt,1,_("Refusing to lose dirty file at%s"),2442 pair->two->path);2443remove_file(opt,1, pair->two->path, !update_wd);24442445/* Find or create a new re->dst_entry */2446 item =string_list_lookup(entries, new_path);2447if(item) {2448/*2449 * Since we're renaming on this side of history, and it's2450 * due to a directory rename on the other side of history2451 * (which we only allow when the directory in question no2452 * longer exists on the other side of history), the2453 * original entry for re->dst_entry is no longer2454 * necessary...2455 */2456 re->dst_entry->processed =1;24572458/*2459 * ...because we'll be using this new one.2460 */2461 re->dst_entry = item->util;2462}else{2463/*2464 * re->dst_entry is for the before-dir-rename path, and we2465 * need it to hold information for the after-dir-rename2466 * path. Before creating a new entry, we need to mark the2467 * old one as unnecessary (...unless it is shared by2468 * src_entry, i.e. this didn't use to be a rename, in which2469 * case we can just allow the normal processing to happen2470 * for it).2471 */2472if(pair->status =='R')2473 re->dst_entry->processed =1;24742475 re->dst_entry =insert_stage_data(new_path,2476 o_tree, a_tree, b_tree,2477 entries);2478 item =string_list_insert(entries, new_path);2479 item->util = re->dst_entry;2480}24812482/*2483 * Update the stage_data with the information about the path we are2484 * moving into place. That slot will be empty and available for us2485 * to write to because of the collision checks in2486 * handle_path_level_conflicts(). In other words,2487 * re->dst_entry->stages[stage].oid will be the null_oid, so it's2488 * open for us to write to.2489 *2490 * It may be tempting to actually update the index at this point as2491 * well, using update_stages_for_stage_data(), but as per the big2492 * "NOTE" in update_stages(), doing so will modify the current2493 * in-memory index which will break calls to would_lose_untracked()2494 * that we need to make. Instead, we need to just make sure that2495 * the various handle_rename_*() functions update the index2496 * explicitly rather than relying on unpack_trees() to have done it.2497 */2498get_tree_entry(&tree->object.oid,2499 pair->two->path,2500&re->dst_entry->stages[stage].oid,2501&re->dst_entry->stages[stage].mode);25022503/*2504 * Record the original change status (or 'type' of change). If it2505 * was originally an add ('A'), this lets us differentiate later2506 * between a RENAME_DELETE conflict and RENAME_VIA_DIR (they2507 * otherwise look the same). If it was originally a rename ('R'),2508 * this lets us remember and report accurately about the transitive2509 * renaming that occurred via the directory rename detection. Also,2510 * record the original destination name.2511 */2512 re->dir_rename_original_type = pair->status;2513 re->dir_rename_original_dest = pair->two->path;25142515/*2516 * We don't actually look at pair->status again, but it seems2517 * pedagogically correct to adjust it.2518 */2519 pair->status ='R';25202521/*2522 * Finally, record the new location.2523 */2524 pair->two->path = new_path;2525}25262527/*2528 * Get information of all renames which occurred in 'pairs', making use of2529 * any implicit directory renames inferred from the other side of history.2530 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')2531 * to be able to associate the correct cache entries with the rename2532 * information; tree is always equal to either a_tree or b_tree.2533 */2534static struct string_list *get_renames(struct merge_options *opt,2535const char*branch,2536struct diff_queue_struct *pairs,2537struct hashmap *dir_renames,2538struct hashmap *dir_rename_exclusions,2539struct tree *tree,2540struct tree *o_tree,2541struct tree *a_tree,2542struct tree *b_tree,2543struct string_list *entries,2544int*clean_merge)2545{2546int i;2547struct hashmap collisions;2548struct hashmap_iter iter;2549struct collision_entry *e;2550struct string_list *renames;25512552compute_collisions(&collisions, dir_renames, pairs);2553 renames =xcalloc(1,sizeof(struct string_list));25542555for(i =0; i < pairs->nr; ++i) {2556struct string_list_item *item;2557struct rename *re;2558struct diff_filepair *pair = pairs->queue[i];2559char*new_path;/* non-NULL only with directory renames */25602561if(pair->status !='A'&& pair->status !='R') {2562diff_free_filepair(pair);2563continue;2564}2565 new_path =check_for_directory_rename(opt, pair->two->path, tree,2566 dir_renames,2567 dir_rename_exclusions,2568&collisions,2569 clean_merge);2570if(pair->status !='R'&& !new_path) {2571diff_free_filepair(pair);2572continue;2573}25742575 re =xmalloc(sizeof(*re));2576 re->processed =0;2577 re->pair = pair;2578 re->branch = branch;2579 re->dir_rename_original_type ='\0';2580 re->dir_rename_original_dest = NULL;2581 item =string_list_lookup(entries, re->pair->one->path);2582if(!item)2583 re->src_entry =insert_stage_data(re->pair->one->path,2584 o_tree, a_tree, b_tree, entries);2585else2586 re->src_entry = item->util;25872588 item =string_list_lookup(entries, re->pair->two->path);2589if(!item)2590 re->dst_entry =insert_stage_data(re->pair->two->path,2591 o_tree, a_tree, b_tree, entries);2592else2593 re->dst_entry = item->util;2594 item =string_list_insert(renames, pair->one->path);2595 item->util = re;2596if(new_path)2597apply_directory_rename_modifications(opt, pair, new_path,2598 re, tree, o_tree,2599 a_tree, b_tree,2600 entries);2601}26022603hashmap_iter_init(&collisions, &iter);2604while((e =hashmap_iter_next(&iter))) {2605free(e->target_file);2606string_list_clear(&e->source_files,0);2607}2608hashmap_free(&collisions,1);2609return renames;2610}26112612static intprocess_renames(struct merge_options *opt,2613struct string_list *a_renames,2614struct string_list *b_renames)2615{2616int clean_merge =1, i, j;2617struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2618struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2619const struct rename *sre;26202621for(i =0; i < a_renames->nr; i++) {2622 sre = a_renames->items[i].util;2623string_list_insert(&a_by_dst, sre->pair->two->path)->util2624= (void*)sre;2625}2626for(i =0; i < b_renames->nr; i++) {2627 sre = b_renames->items[i].util;2628string_list_insert(&b_by_dst, sre->pair->two->path)->util2629= (void*)sre;2630}26312632for(i =0, j =0; i < a_renames->nr || j < b_renames->nr;) {2633struct string_list *renames1, *renames2Dst;2634struct rename *ren1 = NULL, *ren2 = NULL;2635const char*ren1_src, *ren1_dst;2636struct string_list_item *lookup;26372638if(i >= a_renames->nr) {2639 ren2 = b_renames->items[j++].util;2640}else if(j >= b_renames->nr) {2641 ren1 = a_renames->items[i++].util;2642}else{2643int compare =strcmp(a_renames->items[i].string,2644 b_renames->items[j].string);2645if(compare <=0)2646 ren1 = a_renames->items[i++].util;2647if(compare >=0)2648 ren2 = b_renames->items[j++].util;2649}26502651/* TODO: refactor, so that 1/2 are not needed */2652if(ren1) {2653 renames1 = a_renames;2654 renames2Dst = &b_by_dst;2655}else{2656 renames1 = b_renames;2657 renames2Dst = &a_by_dst;2658SWAP(ren2, ren1);2659}26602661if(ren1->processed)2662continue;2663 ren1->processed =1;2664 ren1->dst_entry->processed =1;2665/* BUG: We should only mark src_entry as processed if we2666 * are not dealing with a rename + add-source case.2667 */2668 ren1->src_entry->processed =1;26692670 ren1_src = ren1->pair->one->path;2671 ren1_dst = ren1->pair->two->path;26722673if(ren2) {2674/* One file renamed on both sides */2675const char*ren2_src = ren2->pair->one->path;2676const char*ren2_dst = ren2->pair->two->path;2677enum rename_type rename_type;2678if(strcmp(ren1_src, ren2_src) !=0)2679BUG("ren1_src != ren2_src");2680 ren2->dst_entry->processed =1;2681 ren2->processed =1;2682if(strcmp(ren1_dst, ren2_dst) !=0) {2683 rename_type = RENAME_ONE_FILE_TO_TWO;2684 clean_merge =0;2685}else{2686 rename_type = RENAME_ONE_FILE_TO_ONE;2687/* BUG: We should only remove ren1_src in2688 * the base stage (think of rename +2689 * add-source cases).2690 */2691remove_file(opt,1, ren1_src,1);2692update_entry(ren1->dst_entry,2693 ren1->pair->one,2694 ren1->pair->two,2695 ren2->pair->two);2696}2697setup_rename_conflict_info(rename_type, opt, ren1, ren2);2698}else if((lookup =string_list_lookup(renames2Dst, ren1_dst))) {2699/* Two different files renamed to the same thing */2700char*ren2_dst;2701 ren2 = lookup->util;2702 ren2_dst = ren2->pair->two->path;2703if(strcmp(ren1_dst, ren2_dst) !=0)2704BUG("ren1_dst != ren2_dst");27052706 clean_merge =0;2707 ren2->processed =1;2708/*2709 * BUG: We should only mark src_entry as processed2710 * if we are not dealing with a rename + add-source2711 * case.2712 */2713 ren2->src_entry->processed =1;27142715setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2716 opt, ren1, ren2);2717}else{2718/* Renamed in 1, maybe changed in 2 */2719/* we only use sha1 and mode of these */2720struct diff_filespec src_other, dst_other;2721int try_merge;27222723/*2724 * unpack_trees loads entries from common-commit2725 * into stage 1, from head-commit into stage 2, and2726 * from merge-commit into stage 3. We keep track2727 * of which side corresponds to the rename.2728 */2729int renamed_stage = a_renames == renames1 ?2:3;2730int other_stage = a_renames == renames1 ?3:2;27312732/* BUG: We should only remove ren1_src in the base2733 * stage and in other_stage (think of rename +2734 * add-source case).2735 */2736remove_file(opt,1, ren1_src,2737 renamed_stage ==2|| !was_tracked(opt, ren1_src));27382739oidcpy(&src_other.oid,2740&ren1->src_entry->stages[other_stage].oid);2741 src_other.mode = ren1->src_entry->stages[other_stage].mode;2742oidcpy(&dst_other.oid,2743&ren1->dst_entry->stages[other_stage].oid);2744 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2745 try_merge =0;27462747if(oid_eq(&src_other.oid, &null_oid) &&2748 ren1->dir_rename_original_type =='A') {2749setup_rename_conflict_info(RENAME_VIA_DIR,2750 opt, ren1, NULL);2751}else if(oid_eq(&src_other.oid, &null_oid)) {2752setup_rename_conflict_info(RENAME_DELETE,2753 opt, ren1, NULL);2754}else if((dst_other.mode == ren1->pair->two->mode) &&2755oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2756/*2757 * Added file on the other side identical to2758 * the file being renamed: clean merge.2759 * Also, there is no need to overwrite the2760 * file already in the working copy, so call2761 * update_file_flags() instead of2762 * update_file().2763 */2764if(update_file_flags(opt,2765 ren1->pair->two,2766 ren1_dst,27671,/* update_cache */27680/* update_wd */))2769 clean_merge = -1;2770}else if(!oid_eq(&dst_other.oid, &null_oid)) {2771/*2772 * Probably not a clean merge, but it's2773 * premature to set clean_merge to 0 here,2774 * because if the rename merges cleanly and2775 * the merge exactly matches the newly added2776 * file, then the merge will be clean.2777 */2778setup_rename_conflict_info(RENAME_ADD,2779 opt, ren1, NULL);2780}else2781 try_merge =1;27822783if(clean_merge <0)2784goto cleanup_and_return;2785if(try_merge) {2786struct diff_filespec *o, *a, *b;2787 src_other.path = (char*)ren1_src;27882789 o = ren1->pair->one;2790if(a_renames == renames1) {2791 a = ren1->pair->two;2792 b = &src_other;2793}else{2794 b = ren1->pair->two;2795 a = &src_other;2796}2797update_entry(ren1->dst_entry, o, a, b);2798setup_rename_conflict_info(RENAME_NORMAL,2799 opt, ren1, NULL);2800}2801}2802}2803cleanup_and_return:2804string_list_clear(&a_by_dst,0);2805string_list_clear(&b_by_dst,0);28062807return clean_merge;2808}28092810struct rename_info {2811struct string_list *head_renames;2812struct string_list *merge_renames;2813};28142815static voidinitial_cleanup_rename(struct diff_queue_struct *pairs,2816struct hashmap *dir_renames)2817{2818struct hashmap_iter iter;2819struct dir_rename_entry *e;28202821hashmap_iter_init(dir_renames, &iter);2822while((e =hashmap_iter_next(&iter))) {2823free(e->dir);2824strbuf_release(&e->new_dir);2825/* possible_new_dirs already cleared in get_directory_renames */2826}2827hashmap_free(dir_renames,1);2828free(dir_renames);28292830free(pairs->queue);2831free(pairs);2832}28332834static intdetect_and_process_renames(struct merge_options *opt,2835struct tree *common,2836struct tree *head,2837struct tree *merge,2838struct string_list *entries,2839struct rename_info *ri)2840{2841struct diff_queue_struct *head_pairs, *merge_pairs;2842struct hashmap *dir_re_head, *dir_re_merge;2843int clean =1;28442845 ri->head_renames = NULL;2846 ri->merge_renames = NULL;28472848if(!merge_detect_rename(opt))2849return1;28502851 head_pairs =get_diffpairs(opt, common, head);2852 merge_pairs =get_diffpairs(opt, common, merge);28532854if(opt->detect_directory_renames) {2855 dir_re_head =get_directory_renames(head_pairs);2856 dir_re_merge =get_directory_renames(merge_pairs);28572858handle_directory_level_conflicts(opt,2859 dir_re_head, head,2860 dir_re_merge, merge);2861}else{2862 dir_re_head =xmalloc(sizeof(*dir_re_head));2863 dir_re_merge =xmalloc(sizeof(*dir_re_merge));2864dir_rename_init(dir_re_head);2865dir_rename_init(dir_re_merge);2866}28672868 ri->head_renames =get_renames(opt, opt->branch1, head_pairs,2869 dir_re_merge, dir_re_head, head,2870 common, head, merge, entries,2871&clean);2872if(clean <0)2873goto cleanup;2874 ri->merge_renames =get_renames(opt, opt->branch2, merge_pairs,2875 dir_re_head, dir_re_merge, merge,2876 common, head, merge, entries,2877&clean);2878if(clean <0)2879goto cleanup;2880 clean &=process_renames(opt, ri->head_renames, ri->merge_renames);28812882cleanup:2883/*2884 * Some cleanup is deferred until cleanup_renames() because the2885 * data structures are still needed and referenced in2886 * process_entry(). But there are a few things we can free now.2887 */2888initial_cleanup_rename(head_pairs, dir_re_head);2889initial_cleanup_rename(merge_pairs, dir_re_merge);28902891return clean;2892}28932894static voidfinal_cleanup_rename(struct string_list *rename)2895{2896const struct rename *re;2897int i;28982899if(rename == NULL)2900return;29012902for(i =0; i < rename->nr; i++) {2903 re = rename->items[i].util;2904diff_free_filepair(re->pair);2905}2906string_list_clear(rename,1);2907free(rename);2908}29092910static voidfinal_cleanup_renames(struct rename_info *re_info)2911{2912final_cleanup_rename(re_info->head_renames);2913final_cleanup_rename(re_info->merge_renames);2914}29152916static intread_oid_strbuf(struct merge_options *opt,2917const struct object_id *oid,2918struct strbuf *dst)2919{2920void*buf;2921enum object_type type;2922unsigned long size;2923 buf =read_object_file(oid, &type, &size);2924if(!buf)2925returnerr(opt,_("cannot read object%s"),oid_to_hex(oid));2926if(type != OBJ_BLOB) {2927free(buf);2928returnerr(opt,_("object%sis not a blob"),oid_to_hex(oid));2929}2930strbuf_attach(dst, buf, size, size +1);2931return0;2932}29332934static intblob_unchanged(struct merge_options *opt,2935const struct diff_filespec *o,2936const struct diff_filespec *a,2937int renormalize,const char*path)2938{2939struct strbuf obuf = STRBUF_INIT;2940struct strbuf abuf = STRBUF_INIT;2941int ret =0;/* assume changed for safety */2942const struct index_state *idx = opt->repo->index;29432944if(a->mode != o->mode)2945return0;2946if(oid_eq(&o->oid, &a->oid))2947return1;2948if(!renormalize)2949return0;29502951if(read_oid_strbuf(opt, &o->oid, &obuf) ||2952read_oid_strbuf(opt, &a->oid, &abuf))2953goto error_return;2954/*2955 * Note: binary | is used so that both renormalizations are2956 * performed. Comparison can be skipped if both files are2957 * unchanged since their sha1s have already been compared.2958 */2959if(renormalize_buffer(idx, path, obuf.buf, obuf.len, &obuf) |2960renormalize_buffer(idx, path, abuf.buf, abuf.len, &abuf))2961 ret = (obuf.len == abuf.len && !memcmp(obuf.buf, abuf.buf, obuf.len));29622963error_return:2964strbuf_release(&obuf);2965strbuf_release(&abuf);2966return ret;2967}29682969static inthandle_modify_delete(struct merge_options *opt,2970const char*path,2971const struct diff_filespec *o,2972const struct diff_filespec *a,2973const struct diff_filespec *b)2974{2975const char*modify_branch, *delete_branch;2976const struct diff_filespec *changed;29772978if(is_valid(a)) {2979 modify_branch = opt->branch1;2980 delete_branch = opt->branch2;2981 changed = a;2982}else{2983 modify_branch = opt->branch2;2984 delete_branch = opt->branch1;2985 changed = b;2986}29872988returnhandle_change_delete(opt,2989 path, NULL,2990 o, changed,2991 modify_branch, delete_branch,2992_("modify"),_("modified"));2993}29942995static inthandle_content_merge(struct merge_file_info *mfi,2996struct merge_options *opt,2997const char*path,2998int is_dirty,2999const struct diff_filespec *o,3000const struct diff_filespec *a,3001const struct diff_filespec *b,3002struct rename_conflict_info *ci)3003{3004const char*reason =_("content");3005unsigned df_conflict_remains =0;30063007if(!is_valid(o))3008 reason =_("add/add");30093010assert(o->path && a->path && b->path);3011if(ci &&dir_in_way(opt->repo->index, path, !opt->call_depth,3012S_ISGITLINK(ci->ren1->pair->two->mode)))3013 df_conflict_remains =1;30143015if(merge_mode_and_contents(opt, o, a, b, path,3016 opt->branch1, opt->branch2,3017 opt->call_depth *2, mfi))3018return-1;30193020/*3021 * We can skip updating the working tree file iff:3022 * a) The merge is clean3023 * b) The merge matches what was in HEAD (content, mode, pathname)3024 * c) The target path is usable (i.e. not involved in D/F conflict)3025 */3026if(mfi->clean &&was_tracked_and_matches(opt, path, &mfi->blob) &&3027!df_conflict_remains) {3028int pos;3029struct cache_entry *ce;30303031output(opt,3,_("Skipped%s(merged same as existing)"), path);3032if(add_cacheinfo(opt, &mfi->blob, path,30330, (!opt->call_depth && !is_dirty),0))3034return-1;3035/*3036 * However, add_cacheinfo() will delete the old cache entry3037 * and add a new one. We need to copy over any skip_worktree3038 * flag to avoid making the file appear as if it were3039 * deleted by the user.3040 */3041 pos =index_name_pos(&opt->orig_index, path,strlen(path));3042 ce = opt->orig_index.cache[pos];3043if(ce_skip_worktree(ce)) {3044 pos =index_name_pos(opt->repo->index, path,strlen(path));3045 ce = opt->repo->index->cache[pos];3046 ce->ce_flags |= CE_SKIP_WORKTREE;3047}3048return mfi->clean;3049}30503051if(!mfi->clean) {3052if(S_ISGITLINK(mfi->blob.mode))3053 reason =_("submodule");3054output(opt,1,_("CONFLICT (%s): Merge conflict in%s"),3055 reason, path);3056if(ci && !df_conflict_remains)3057if(update_stages(opt, path, o, a, b))3058return-1;3059}30603061if(df_conflict_remains || is_dirty) {3062char*new_path;3063if(opt->call_depth) {3064remove_file_from_index(opt->repo->index, path);3065}else{3066if(!mfi->clean) {3067if(update_stages(opt, path, o, a, b))3068return-1;3069}else{3070int file_from_stage2 =was_tracked(opt, path);30713072if(update_stages(opt, path, NULL,3073 file_from_stage2 ? &mfi->blob : NULL,3074 file_from_stage2 ? NULL : &mfi->blob))3075return-1;3076}30773078}3079 new_path =unique_path(opt, path, ci->ren1->branch);3080if(is_dirty) {3081output(opt,1,_("Refusing to lose dirty file at%s"),3082 path);3083}3084output(opt,1,_("Adding as%sinstead"), new_path);3085if(update_file(opt,0, &mfi->blob, new_path)) {3086free(new_path);3087return-1;3088}3089free(new_path);3090 mfi->clean =0;3091}else if(update_file(opt, mfi->clean, &mfi->blob, path))3092return-1;3093return!is_dirty && mfi->clean;3094}30953096static inthandle_rename_normal(struct merge_options *opt,3097const char*path,3098const struct diff_filespec *o,3099const struct diff_filespec *a,3100const struct diff_filespec *b,3101struct rename_conflict_info *ci)3102{3103struct rename *ren = ci->ren1;3104struct merge_file_info mfi;3105int clean;3106int side = (ren->branch == opt->branch1 ?2:3);31073108/* Merge the content and write it out */3109 clean =handle_content_merge(&mfi, opt, path,was_dirty(opt, path),3110 o, a, b, ci);31113112if(clean && opt->detect_directory_renames ==1&&3113 ren->dir_rename_original_dest) {3114if(update_stages(opt, path,3115 NULL,3116 side ==2? &mfi.blob : NULL,3117 side ==2? NULL : &mfi.blob))3118return-1;3119 clean =0;/* not clean, but conflicted */3120}3121return clean;3122}31233124static voiddir_rename_warning(const char*msg,3125int is_add,3126int clean,3127struct merge_options *opt,3128struct rename *ren)3129{3130const char*other_branch;3131 other_branch = (ren->branch == opt->branch1 ?3132 opt->branch2 : opt->branch1);3133if(is_add) {3134output(opt, clean ?2:1, msg,3135 ren->pair->one->path, ren->branch,3136 other_branch, ren->pair->two->path);3137return;3138}3139output(opt, clean ?2:1, msg,3140 ren->pair->one->path, ren->dir_rename_original_dest, ren->branch,3141 other_branch, ren->pair->two->path);3142}3143static intwarn_about_dir_renamed_entries(struct merge_options *opt,3144struct rename *ren)3145{3146const char*msg;3147int clean =1, is_add;31483149if(!ren)3150return clean;31513152/* Return early if ren was not affected/created by a directory rename */3153if(!ren->dir_rename_original_dest)3154return clean;31553156/* Sanity checks */3157assert(opt->detect_directory_renames >0);3158assert(ren->dir_rename_original_type =='A'||3159 ren->dir_rename_original_type =='R');31603161/* Check whether to treat directory renames as a conflict */3162 clean = (opt->detect_directory_renames ==2);31633164 is_add = (ren->dir_rename_original_type =='A');3165if(ren->dir_rename_original_type =='A'&& clean) {3166 msg =_("Path updated:%sadded in%sinside a "3167"directory that was renamed in%s; moving it to%s.");3168}else if(ren->dir_rename_original_type =='A'&& !clean) {3169 msg =_("CONFLICT (file location):%sadded in%s"3170"inside a directory that was renamed in%s, "3171"suggesting it should perhaps be moved to%s.");3172}else if(ren->dir_rename_original_type =='R'&& clean) {3173 msg =_("Path updated:%srenamed to%sin%s, inside a "3174"directory that was renamed in%s; moving it to%s.");3175}else if(ren->dir_rename_original_type =='R'&& !clean) {3176 msg =_("CONFLICT (file location):%srenamed to%sin%s, "3177"inside a directory that was renamed in%s, "3178"suggesting it should perhaps be moved to%s.");3179}else{3180BUG("Impossible dir_rename_original_type/clean combination");3181}3182dir_rename_warning(msg, is_add, clean, opt, ren);31833184return clean;3185}31863187/* Per entry merge function */3188static intprocess_entry(struct merge_options *opt,3189const char*path,struct stage_data *entry)3190{3191int clean_merge =1;3192int normalize = opt->renormalize;31933194struct diff_filespec *o = &entry->stages[1];3195struct diff_filespec *a = &entry->stages[2];3196struct diff_filespec *b = &entry->stages[3];3197int o_valid =is_valid(o);3198int a_valid =is_valid(a);3199int b_valid =is_valid(b);3200 o->path = a->path = b->path = (char*)path;32013202 entry->processed =1;3203if(entry->rename_conflict_info) {3204struct rename_conflict_info *ci = entry->rename_conflict_info;3205struct diff_filespec *temp;3206int path_clean;32073208 path_clean =warn_about_dir_renamed_entries(opt, ci->ren1);3209 path_clean &=warn_about_dir_renamed_entries(opt, ci->ren2);32103211/*3212 * For cases with a single rename, {o,a,b}->path have all been3213 * set to the rename target path; we need to set two of these3214 * back to the rename source.3215 * For rename/rename conflicts, we'll manually fix paths below.3216 */3217 temp = (opt->branch1 == ci->ren1->branch) ? b : a;3218 o->path = temp->path = ci->ren1->pair->one->path;3219if(ci->ren2) {3220assert(opt->branch1 == ci->ren1->branch);3221}32223223switch(ci->rename_type) {3224case RENAME_NORMAL:3225case RENAME_ONE_FILE_TO_ONE:3226 clean_merge =handle_rename_normal(opt, path, o, a, b,3227 ci);3228break;3229case RENAME_VIA_DIR:3230 clean_merge =handle_rename_via_dir(opt, ci);3231break;3232case RENAME_ADD:3233/*3234 * Probably unclean merge, but if the renamed file3235 * merges cleanly and the result can then be3236 * two-way merged cleanly with the added file, I3237 * guess it's a clean merge?3238 */3239 clean_merge =handle_rename_add(opt, ci);3240break;3241case RENAME_DELETE:3242 clean_merge =0;3243if(handle_rename_delete(opt, ci))3244 clean_merge = -1;3245break;3246case RENAME_ONE_FILE_TO_TWO:3247/*3248 * Manually fix up paths; note:3249 * ren[12]->pair->one->path are equal.3250 */3251 o->path = ci->ren1->pair->one->path;3252 a->path = ci->ren1->pair->two->path;3253 b->path = ci->ren2->pair->two->path;32543255 clean_merge =0;3256if(handle_rename_rename_1to2(opt, ci))3257 clean_merge = -1;3258break;3259case RENAME_TWO_FILES_TO_ONE:3260/*3261 * Manually fix up paths; note,3262 * ren[12]->pair->two->path are actually equal.3263 */3264 o->path = NULL;3265 a->path = ci->ren1->pair->two->path;3266 b->path = ci->ren2->pair->two->path;32673268/*3269 * Probably unclean merge, but if the two renamed3270 * files merge cleanly and the two resulting files3271 * can then be two-way merged cleanly, I guess it's3272 * a clean merge?3273 */3274 clean_merge =handle_rename_rename_2to1(opt, ci);3275break;3276default:3277 entry->processed =0;3278break;3279}3280if(path_clean < clean_merge)3281 clean_merge = path_clean;3282}else if(o_valid && (!a_valid || !b_valid)) {3283/* Case A: Deleted in one */3284if((!a_valid && !b_valid) ||3285(!b_valid &&blob_unchanged(opt, o, a, normalize, path)) ||3286(!a_valid &&blob_unchanged(opt, o, b, normalize, path))) {3287/* Deleted in both or deleted in one and3288 * unchanged in the other */3289if(a_valid)3290output(opt,2,_("Removing%s"), path);3291/* do not touch working file if it did not exist */3292remove_file(opt,1, path, !a_valid);3293}else{3294/* Modify/delete; deleted side may have put a directory in the way */3295 clean_merge =0;3296if(handle_modify_delete(opt, path, o, a, b))3297 clean_merge = -1;3298}3299}else if((!o_valid && a_valid && !b_valid) ||3300(!o_valid && !a_valid && b_valid)) {3301/* Case B: Added in one. */3302/* [nothing|directory] -> ([nothing|directory], file) */33033304const char*add_branch;3305const char*other_branch;3306const char*conf;3307const struct diff_filespec *contents;33083309if(a_valid) {3310 add_branch = opt->branch1;3311 other_branch = opt->branch2;3312 contents = a;3313 conf =_("file/directory");3314}else{3315 add_branch = opt->branch2;3316 other_branch = opt->branch1;3317 contents = b;3318 conf =_("directory/file");3319}3320if(dir_in_way(opt->repo->index, path,3321!opt->call_depth && !S_ISGITLINK(a->mode),33220)) {3323char*new_path =unique_path(opt, path, add_branch);3324 clean_merge =0;3325output(opt,1,_("CONFLICT (%s): There is a directory with name%sin%s. "3326"Adding%sas%s"),3327 conf, path, other_branch, path, new_path);3328if(update_file(opt,0, contents, new_path))3329 clean_merge = -1;3330else if(opt->call_depth)3331remove_file_from_index(opt->repo->index, path);3332free(new_path);3333}else{3334output(opt,2,_("Adding%s"), path);3335/* do not overwrite file if already present */3336if(update_file_flags(opt, contents, path,1, !a_valid))3337 clean_merge = -1;3338}3339}else if(a_valid && b_valid) {3340if(!o_valid) {3341/* Case C: Added in both (check for same permissions) */3342output(opt,1,3343_("CONFLICT (add/add): Merge conflict in%s"),3344 path);3345 clean_merge =handle_file_collision(opt,3346 path, NULL, NULL,3347 opt->branch1,3348 opt->branch2,3349 a, b);3350}else{3351/* case D: Modified in both, but differently. */3352struct merge_file_info mfi;3353int is_dirty =0;/* unpack_trees would have bailed if dirty */3354 clean_merge =handle_content_merge(&mfi, opt, path,3355 is_dirty,3356 o, a, b, NULL);3357}3358}else if(!o_valid && !a_valid && !b_valid) {3359/*3360 * this entry was deleted altogether. a_mode == 0 means3361 * we had that path and want to actively remove it.3362 */3363remove_file(opt,1, path, !a->mode);3364}else3365BUG("fatal merge failure, shouldn't happen.");33663367return clean_merge;3368}33693370intmerge_trees(struct merge_options *opt,3371struct tree *head,3372struct tree *merge,3373struct tree *common,3374struct tree **result)3375{3376struct index_state *istate = opt->repo->index;3377int code, clean;3378struct strbuf sb = STRBUF_INIT;33793380if(!opt->call_depth &&repo_index_has_changes(opt->repo, head, &sb)) {3381err(opt,_("Your local changes to the following files would be overwritten by merge:\n%s"),3382 sb.buf);3383return-1;3384}33853386if(opt->subtree_shift) {3387 merge =shift_tree_object(opt->repo, head, merge, opt->subtree_shift);3388 common =shift_tree_object(opt->repo, head, common, opt->subtree_shift);3389}33903391if(oid_eq(&common->object.oid, &merge->object.oid)) {3392output(opt,0,_("Already up to date!"));3393*result = head;3394return1;3395}33963397 code =unpack_trees_start(opt, common, head, merge);33983399if(code !=0) {3400if(show(opt,4) || opt->call_depth)3401err(opt,_("merging of trees%sand%sfailed"),3402oid_to_hex(&head->object.oid),3403oid_to_hex(&merge->object.oid));3404unpack_trees_finish(opt);3405return-1;3406}34073408if(unmerged_index(istate)) {3409struct string_list *entries;3410struct rename_info re_info;3411int i;3412/*3413 * Only need the hashmap while processing entries, so3414 * initialize it here and free it when we are done running3415 * through the entries. Keeping it in the merge_options as3416 * opposed to decaring a local hashmap is for convenience3417 * so that we don't have to pass it to around.3418 */3419hashmap_init(&opt->current_file_dir_set, path_hashmap_cmp, NULL,512);3420get_files_dirs(opt, head);3421get_files_dirs(opt, merge);34223423 entries =get_unmerged(opt->repo->index);3424 clean =detect_and_process_renames(opt, common, head, merge,3425 entries, &re_info);3426record_df_conflict_files(opt, entries);3427if(clean <0)3428goto cleanup;3429for(i = entries->nr-1;0<= i; i--) {3430const char*path = entries->items[i].string;3431struct stage_data *e = entries->items[i].util;3432if(!e->processed) {3433int ret =process_entry(opt, path, e);3434if(!ret)3435 clean =0;3436else if(ret <0) {3437 clean = ret;3438goto cleanup;3439}3440}3441}3442for(i =0; i < entries->nr; i++) {3443struct stage_data *e = entries->items[i].util;3444if(!e->processed)3445BUG("unprocessed path???%s",3446 entries->items[i].string);3447}34483449 cleanup:3450final_cleanup_renames(&re_info);34513452string_list_clear(entries,1);3453free(entries);34543455hashmap_free(&opt->current_file_dir_set,1);34563457if(clean <0) {3458unpack_trees_finish(opt);3459return clean;3460}3461}3462else3463 clean =1;34643465unpack_trees_finish(opt);34663467if(opt->call_depth && !(*result =write_tree_from_memory(opt)))3468return-1;34693470return clean;3471}34723473static struct commit_list *reverse_commit_list(struct commit_list *list)3474{3475struct commit_list *next = NULL, *current, *backup;3476for(current = list; current; current = backup) {3477 backup = current->next;3478 current->next = next;3479 next = current;3480}3481return next;3482}34833484/*3485 * Merge the commits h1 and h2, return the resulting virtual3486 * commit object and a flag indicating the cleanness of the merge.3487 */3488intmerge_recursive(struct merge_options *opt,3489struct commit *h1,3490struct commit *h2,3491struct commit_list *ca,3492struct commit **result)3493{3494struct commit_list *iter;3495struct commit *merged_common_ancestors;3496struct tree *mrtree;3497int clean;34983499if(show(opt,4)) {3500output(opt,4,_("Merging:"));3501output_commit_title(opt, h1);3502output_commit_title(opt, h2);3503}35043505if(!ca) {3506 ca =get_merge_bases(h1, h2);3507 ca =reverse_commit_list(ca);3508}35093510if(show(opt,5)) {3511unsigned cnt =commit_list_count(ca);35123513output(opt,5,Q_("found%ucommon ancestor:",3514"found%ucommon ancestors:", cnt), cnt);3515for(iter = ca; iter; iter = iter->next)3516output_commit_title(opt, iter->item);3517}35183519 merged_common_ancestors =pop_commit(&ca);3520if(merged_common_ancestors == NULL) {3521/* if there is no common ancestor, use an empty tree */3522struct tree *tree;35233524 tree =lookup_tree(opt->repo, opt->repo->hash_algo->empty_tree);3525 merged_common_ancestors =make_virtual_commit(opt->repo, tree,"ancestor");3526}35273528for(iter = ca; iter; iter = iter->next) {3529const char*saved_b1, *saved_b2;3530 opt->call_depth++;3531/*3532 * When the merge fails, the result contains files3533 * with conflict markers. The cleanness flag is3534 * ignored (unless indicating an error), it was never3535 * actually used, as result of merge_trees has always3536 * overwritten it: the committed "conflicts" were3537 * already resolved.3538 */3539discard_index(opt->repo->index);3540 saved_b1 = opt->branch1;3541 saved_b2 = opt->branch2;3542 opt->branch1 ="Temporary merge branch 1";3543 opt->branch2 ="Temporary merge branch 2";3544if(merge_recursive(opt, merged_common_ancestors, iter->item,3545 NULL, &merged_common_ancestors) <0)3546return-1;3547 opt->branch1 = saved_b1;3548 opt->branch2 = saved_b2;3549 opt->call_depth--;35503551if(!merged_common_ancestors)3552returnerr(opt,_("merge returned no commit"));3553}35543555discard_index(opt->repo->index);3556if(!opt->call_depth)3557repo_read_index(opt->repo);35583559 opt->ancestor ="merged common ancestors";3560 clean =merge_trees(opt,get_commit_tree(h1),get_commit_tree(h2),3561get_commit_tree(merged_common_ancestors),3562&mrtree);3563if(clean <0) {3564flush_output(opt);3565return clean;3566}35673568if(opt->call_depth) {3569*result =make_virtual_commit(opt->repo, mrtree,"merged tree");3570commit_list_insert(h1, &(*result)->parents);3571commit_list_insert(h2, &(*result)->parents->next);3572}3573flush_output(opt);3574if(!opt->call_depth && opt->buffer_output <2)3575strbuf_release(&opt->obuf);3576if(show(opt,2))3577diff_warn_rename_limit("merge.renamelimit",3578 opt->needed_rename_limit,0);3579return clean;3580}35813582static struct commit *get_ref(struct repository *repo,const struct object_id *oid,3583const char*name)3584{3585struct object *object;35863587 object =deref_tag(repo,parse_object(repo, oid),3588 name,strlen(name));3589if(!object)3590return NULL;3591if(object->type == OBJ_TREE)3592returnmake_virtual_commit(repo, (struct tree*)object, name);3593if(object->type != OBJ_COMMIT)3594return NULL;3595if(parse_commit((struct commit *)object))3596return NULL;3597return(struct commit *)object;3598}35993600intmerge_recursive_generic(struct merge_options *opt,3601const struct object_id *head,3602const struct object_id *merge,3603int num_base_list,3604const struct object_id **base_list,3605struct commit **result)3606{3607int clean;3608struct lock_file lock = LOCK_INIT;3609struct commit *head_commit =get_ref(opt->repo, head, opt->branch1);3610struct commit *next_commit =get_ref(opt->repo, merge, opt->branch2);3611struct commit_list *ca = NULL;36123613if(base_list) {3614int i;3615for(i =0; i < num_base_list; ++i) {3616struct commit *base;3617if(!(base =get_ref(opt->repo, base_list[i],oid_to_hex(base_list[i]))))3618returnerr(opt,_("Could not parse object '%s'"),3619oid_to_hex(base_list[i]));3620commit_list_insert(base, &ca);3621}3622}36233624repo_hold_locked_index(opt->repo, &lock, LOCK_DIE_ON_ERROR);3625 clean =merge_recursive(opt, head_commit, next_commit, ca,3626 result);3627if(clean <0) {3628rollback_lock_file(&lock);3629return clean;3630}36313632if(write_locked_index(opt->repo->index, &lock,3633 COMMIT_LOCK | SKIP_IF_UNCHANGED))3634returnerr(opt,_("Unable to write index."));36353636return clean ?0:1;3637}36383639static voidmerge_recursive_config(struct merge_options *opt)3640{3641char*value = NULL;3642git_config_get_int("merge.verbosity", &opt->verbosity);3643git_config_get_int("diff.renamelimit", &opt->diff_rename_limit);3644git_config_get_int("merge.renamelimit", &opt->merge_rename_limit);3645if(!git_config_get_string("diff.renames", &value)) {3646 opt->diff_detect_rename =git_config_rename("diff.renames", value);3647free(value);3648}3649if(!git_config_get_string("merge.renames", &value)) {3650 opt->merge_detect_rename =git_config_rename("merge.renames", value);3651free(value);3652}3653if(!git_config_get_string("merge.directoryrenames", &value)) {3654int boolval =git_parse_maybe_bool(value);3655if(0<= boolval) {3656 opt->detect_directory_renames = boolval ?2:0;3657}else if(!strcasecmp(value,"conflict")) {3658 opt->detect_directory_renames =1;3659}/* avoid erroring on values from future versions of git */3660free(value);3661}3662git_config(git_xmerge_config, NULL);3663}36643665voidinit_merge_options(struct merge_options *opt,3666struct repository *repo)3667{3668const char*merge_verbosity;3669memset(opt,0,sizeof(struct merge_options));3670 opt->repo = repo;3671 opt->verbosity =2;3672 opt->buffer_output =1;3673 opt->diff_rename_limit = -1;3674 opt->merge_rename_limit = -1;3675 opt->renormalize =0;3676 opt->diff_detect_rename = -1;3677 opt->merge_detect_rename = -1;3678 opt->detect_directory_renames =1;3679merge_recursive_config(opt);3680 merge_verbosity =getenv("GIT_MERGE_VERBOSITY");3681if(merge_verbosity)3682 opt->verbosity =strtol(merge_verbosity, NULL,10);3683if(opt->verbosity >=5)3684 opt->buffer_output =0;3685strbuf_init(&opt->obuf,0);3686string_list_init(&opt->df_conflict_file_set,1);3687}36883689intparse_merge_opt(struct merge_options *opt,const char*s)3690{3691const char*arg;36923693if(!s || !*s)3694return-1;3695if(!strcmp(s,"ours"))3696 opt->recursive_variant = MERGE_RECURSIVE_OURS;3697else if(!strcmp(s,"theirs"))3698 opt->recursive_variant = MERGE_RECURSIVE_THEIRS;3699else if(!strcmp(s,"subtree"))3700 opt->subtree_shift ="";3701else if(skip_prefix(s,"subtree=", &arg))3702 opt->subtree_shift = arg;3703else if(!strcmp(s,"patience"))3704 opt->xdl_opts =DIFF_WITH_ALG(opt, PATIENCE_DIFF);3705else if(!strcmp(s,"histogram"))3706 opt->xdl_opts =DIFF_WITH_ALG(opt, HISTOGRAM_DIFF);3707else if(skip_prefix(s,"diff-algorithm=", &arg)) {3708long value =parse_algorithm_value(arg);3709if(value <0)3710return-1;3711/* clear out previous settings */3712DIFF_XDL_CLR(opt, NEED_MINIMAL);3713 opt->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3714 opt->xdl_opts |= value;3715}3716else if(!strcmp(s,"ignore-space-change"))3717DIFF_XDL_SET(opt, IGNORE_WHITESPACE_CHANGE);3718else if(!strcmp(s,"ignore-all-space"))3719DIFF_XDL_SET(opt, IGNORE_WHITESPACE);3720else if(!strcmp(s,"ignore-space-at-eol"))3721DIFF_XDL_SET(opt, IGNORE_WHITESPACE_AT_EOL);3722else if(!strcmp(s,"ignore-cr-at-eol"))3723DIFF_XDL_SET(opt, IGNORE_CR_AT_EOL);3724else if(!strcmp(s,"renormalize"))3725 opt->renormalize =1;3726else if(!strcmp(s,"no-renormalize"))3727 opt->renormalize =0;3728else if(!strcmp(s,"no-renames"))3729 opt->merge_detect_rename =0;3730else if(!strcmp(s,"find-renames")) {3731 opt->merge_detect_rename =1;3732 opt->rename_score =0;3733}3734else if(skip_prefix(s,"find-renames=", &arg) ||3735skip_prefix(s,"rename-threshold=", &arg)) {3736if((opt->rename_score =parse_rename_score(&arg)) == -1|| *arg !=0)3737return-1;3738 opt->merge_detect_rename =1;3739}3740/*3741 * Please update $__git_merge_strategy_options in3742 * git-completion.bash when you add new options3743 */3744else3745return-1;3746return0;3747}