1/* 2 * Recursive Merge algorithm stolen from git-merge-recursive.py by 3 * Fredrik Kuivinen. 4 * The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006 5 */ 6#include"cache.h" 7#include"config.h" 8#include"advice.h" 9#include"lockfile.h" 10#include"cache-tree.h" 11#include"object-store.h" 12#include"repository.h" 13#include"commit.h" 14#include"blob.h" 15#include"builtin.h" 16#include"tree-walk.h" 17#include"diff.h" 18#include"diffcore.h" 19#include"tag.h" 20#include"alloc.h" 21#include"unpack-trees.h" 22#include"string-list.h" 23#include"xdiff-interface.h" 24#include"ll-merge.h" 25#include"attr.h" 26#include"merge-recursive.h" 27#include"dir.h" 28#include"submodule.h" 29#include"revision.h" 30#include"commit-reach.h" 31 32struct path_hashmap_entry { 33struct hashmap_entry e; 34char path[FLEX_ARRAY]; 35}; 36 37static intpath_hashmap_cmp(const void*cmp_data, 38const void*entry, 39const void*entry_or_key, 40const void*keydata) 41{ 42const struct path_hashmap_entry *a = entry; 43const struct path_hashmap_entry *b = entry_or_key; 44const char*key = keydata; 45 46if(ignore_case) 47returnstrcasecmp(a->path, key ? key : b->path); 48else 49returnstrcmp(a->path, key ? key : b->path); 50} 51 52static unsigned intpath_hash(const char*path) 53{ 54return ignore_case ?strihash(path) :strhash(path); 55} 56 57static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap, 58char*dir) 59{ 60struct dir_rename_entry key; 61 62if(dir == NULL) 63return NULL; 64hashmap_entry_init(&key,strhash(dir)); 65 key.dir = dir; 66returnhashmap_get(hashmap, &key, NULL); 67} 68 69static intdir_rename_cmp(const void*unused_cmp_data, 70const void*entry, 71const void*entry_or_key, 72const void*unused_keydata) 73{ 74const struct dir_rename_entry *e1 = entry; 75const struct dir_rename_entry *e2 = entry_or_key; 76 77returnstrcmp(e1->dir, e2->dir); 78} 79 80static voiddir_rename_init(struct hashmap *map) 81{ 82hashmap_init(map, dir_rename_cmp, NULL,0); 83} 84 85static voiddir_rename_entry_init(struct dir_rename_entry *entry, 86char*directory) 87{ 88hashmap_entry_init(entry,strhash(directory)); 89 entry->dir = directory; 90 entry->non_unique_new_dir =0; 91strbuf_init(&entry->new_dir,0); 92string_list_init(&entry->possible_new_dirs,0); 93} 94 95static struct collision_entry *collision_find_entry(struct hashmap *hashmap, 96char*target_file) 97{ 98struct collision_entry key; 99 100hashmap_entry_init(&key,strhash(target_file)); 101 key.target_file = target_file; 102returnhashmap_get(hashmap, &key, NULL); 103} 104 105static intcollision_cmp(void*unused_cmp_data, 106const struct collision_entry *e1, 107const struct collision_entry *e2, 108const void*unused_keydata) 109{ 110returnstrcmp(e1->target_file, e2->target_file); 111} 112 113static voidcollision_init(struct hashmap *map) 114{ 115hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL,0); 116} 117 118static voidflush_output(struct merge_options *o) 119{ 120if(o->buffer_output <2&& o->obuf.len) { 121fputs(o->obuf.buf, stdout); 122strbuf_reset(&o->obuf); 123} 124} 125 126static interr(struct merge_options *o,const char*err, ...) 127{ 128va_list params; 129 130if(o->buffer_output <2) 131flush_output(o); 132else{ 133strbuf_complete(&o->obuf,'\n'); 134strbuf_addstr(&o->obuf,"error: "); 135} 136va_start(params, err); 137strbuf_vaddf(&o->obuf, err, params); 138va_end(params); 139if(o->buffer_output >1) 140strbuf_addch(&o->obuf,'\n'); 141else{ 142error("%s", o->obuf.buf); 143strbuf_reset(&o->obuf); 144} 145 146return-1; 147} 148 149static struct tree *shift_tree_object(struct tree *one,struct tree *two, 150const char*subtree_shift) 151{ 152struct object_id shifted; 153 154if(!*subtree_shift) { 155shift_tree(&one->object.oid, &two->object.oid, &shifted,0); 156}else{ 157shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 158 subtree_shift); 159} 160if(oideq(&two->object.oid, &shifted)) 161return two; 162returnlookup_tree(the_repository, &shifted); 163} 164 165static struct commit *make_virtual_commit(struct tree *tree,const char*comment) 166{ 167struct commit *commit =alloc_commit_node(the_repository); 168 169set_merge_remote_desc(commit, comment, (struct object *)commit); 170 commit->maybe_tree = tree; 171 commit->object.parsed =1; 172return commit; 173} 174 175/* 176 * Since we use get_tree_entry(), which does not put the read object into 177 * the object pool, we cannot rely on a == b. 178 */ 179static intoid_eq(const struct object_id *a,const struct object_id *b) 180{ 181if(!a && !b) 182return2; 183return a && b &&oideq(a, b); 184} 185 186enum rename_type { 187 RENAME_NORMAL =0, 188 RENAME_VIA_DIR, 189 RENAME_ADD, 190 RENAME_DELETE, 191 RENAME_ONE_FILE_TO_ONE, 192 RENAME_ONE_FILE_TO_TWO, 193 RENAME_TWO_FILES_TO_ONE 194}; 195 196struct rename_conflict_info { 197enum rename_type rename_type; 198struct diff_filepair *pair1; 199struct diff_filepair *pair2; 200const char*branch1; 201const char*branch2; 202struct stage_data *dst_entry1; 203struct stage_data *dst_entry2; 204struct diff_filespec ren1_other; 205struct diff_filespec ren2_other; 206}; 207 208/* 209 * Since we want to write the index eventually, we cannot reuse the index 210 * for these (temporary) data. 211 */ 212struct stage_data { 213struct{ 214unsigned mode; 215struct object_id oid; 216} stages[4]; 217struct rename_conflict_info *rename_conflict_info; 218unsigned processed:1; 219}; 220 221staticinlinevoidsetup_rename_conflict_info(enum rename_type rename_type, 222struct diff_filepair *pair1, 223struct diff_filepair *pair2, 224const char*branch1, 225const char*branch2, 226struct stage_data *dst_entry1, 227struct stage_data *dst_entry2, 228struct merge_options *o, 229struct stage_data *src_entry1, 230struct stage_data *src_entry2) 231{ 232int ostage1 =0, ostage2; 233struct rename_conflict_info *ci; 234 235/* 236 * When we have two renames involved, it's easiest to get the 237 * correct things into stage 2 and 3, and to make sure that the 238 * content merge puts HEAD before the other branch if we just 239 * ensure that branch1 == o->branch1. So, simply flip arguments 240 * around if we don't have that. 241 */ 242if(dst_entry2 && branch1 != o->branch1) { 243setup_rename_conflict_info(rename_type, 244 pair2, pair1, 245 branch2, branch1, 246 dst_entry2, dst_entry1, 247 o, 248 src_entry2, src_entry1); 249return; 250} 251 252 ci =xcalloc(1,sizeof(struct rename_conflict_info)); 253 ci->rename_type = rename_type; 254 ci->pair1 = pair1; 255 ci->branch1 = branch1; 256 ci->branch2 = branch2; 257 258 ci->dst_entry1 = dst_entry1; 259 dst_entry1->rename_conflict_info = ci; 260 dst_entry1->processed =0; 261 262assert(!pair2 == !dst_entry2); 263if(dst_entry2) { 264 ci->dst_entry2 = dst_entry2; 265 ci->pair2 = pair2; 266 dst_entry2->rename_conflict_info = ci; 267} 268 269/* 270 * For each rename, there could have been 271 * modifications on the side of history where that 272 * file was not renamed. 273 */ 274if(rename_type == RENAME_ADD || 275 rename_type == RENAME_TWO_FILES_TO_ONE) { 276 ostage1 = o->branch1 == branch1 ?3:2; 277 278 ci->ren1_other.path = pair1->one->path; 279oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid); 280 ci->ren1_other.mode = src_entry1->stages[ostage1].mode; 281} 282 283if(rename_type == RENAME_TWO_FILES_TO_ONE) { 284 ostage2 = ostage1 ^1; 285 286 ci->ren2_other.path = pair2->one->path; 287oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid); 288 ci->ren2_other.mode = src_entry2->stages[ostage2].mode; 289} 290} 291 292static intshow(struct merge_options *o,int v) 293{ 294return(!o->call_depth && o->verbosity >= v) || o->verbosity >=5; 295} 296 297__attribute__((format(printf,3,4))) 298static voidoutput(struct merge_options *o,int v,const char*fmt, ...) 299{ 300va_list ap; 301 302if(!show(o, v)) 303return; 304 305strbuf_addchars(&o->obuf,' ', o->call_depth *2); 306 307va_start(ap, fmt); 308strbuf_vaddf(&o->obuf, fmt, ap); 309va_end(ap); 310 311strbuf_addch(&o->obuf,'\n'); 312if(!o->buffer_output) 313flush_output(o); 314} 315 316static voidoutput_commit_title(struct merge_options *o,struct commit *commit) 317{ 318struct merge_remote_desc *desc; 319 320strbuf_addchars(&o->obuf,' ', o->call_depth *2); 321 desc =merge_remote_util(commit); 322if(desc) 323strbuf_addf(&o->obuf,"virtual%s\n", desc->name); 324else{ 325strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid, 326 DEFAULT_ABBREV); 327strbuf_addch(&o->obuf,' '); 328if(parse_commit(commit) !=0) 329strbuf_addstr(&o->obuf,_("(bad commit)\n")); 330else{ 331const char*title; 332const char*msg =get_commit_buffer(commit, NULL); 333int len =find_commit_subject(msg, &title); 334if(len) 335strbuf_addf(&o->obuf,"%.*s\n", len, title); 336unuse_commit_buffer(commit, msg); 337} 338} 339flush_output(o); 340} 341 342static intadd_cacheinfo(struct merge_options *o, 343unsigned int mode,const struct object_id *oid, 344const char*path,int stage,int refresh,int options) 345{ 346struct index_state *istate = o->repo->index; 347struct cache_entry *ce; 348int ret; 349 350 ce =make_cache_entry(istate, mode, oid ? oid : &null_oid, path, stage,0); 351if(!ce) 352returnerr(o,_("add_cacheinfo failed for path '%s'; merge aborting."), path); 353 354 ret =add_index_entry(istate, ce, options); 355if(refresh) { 356struct cache_entry *nce; 357 358 nce =refresh_cache_entry(istate, ce, 359 CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 360if(!nce) 361returnerr(o,_("add_cacheinfo failed to refresh for path '%s'; merge aborting."), path); 362if(nce != ce) 363 ret =add_index_entry(istate, nce, options); 364} 365return ret; 366} 367 368static voidinit_tree_desc_from_tree(struct tree_desc *desc,struct tree *tree) 369{ 370parse_tree(tree); 371init_tree_desc(desc, tree->buffer, tree->size); 372} 373 374static intunpack_trees_start(struct merge_options *o, 375struct tree *common, 376struct tree *head, 377struct tree *merge) 378{ 379int rc; 380struct tree_desc t[3]; 381struct index_state tmp_index = { NULL }; 382 383memset(&o->unpack_opts,0,sizeof(o->unpack_opts)); 384if(o->call_depth) 385 o->unpack_opts.index_only =1; 386else 387 o->unpack_opts.update =1; 388 o->unpack_opts.merge =1; 389 o->unpack_opts.head_idx =2; 390 o->unpack_opts.fn = threeway_merge; 391 o->unpack_opts.src_index = o->repo->index; 392 o->unpack_opts.dst_index = &tmp_index; 393 o->unpack_opts.aggressive = !merge_detect_rename(o); 394setup_unpack_trees_porcelain(&o->unpack_opts,"merge"); 395 396init_tree_desc_from_tree(t+0, common); 397init_tree_desc_from_tree(t+1, head); 398init_tree_desc_from_tree(t+2, merge); 399 400 rc =unpack_trees(3, t, &o->unpack_opts); 401cache_tree_free(&o->repo->index->cache_tree); 402 403/* 404 * Update o->repo->index to match the new results, AFTER saving a copy 405 * in o->orig_index. Update src_index to point to the saved copy. 406 * (verify_uptodate() checks src_index, and the original index is 407 * the one that had the necessary modification timestamps.) 408 */ 409 o->orig_index = *o->repo->index; 410*o->repo->index = tmp_index; 411 o->unpack_opts.src_index = &o->orig_index; 412 413return rc; 414} 415 416static voidunpack_trees_finish(struct merge_options *o) 417{ 418discard_index(&o->orig_index); 419clear_unpack_trees_porcelain(&o->unpack_opts); 420} 421 422struct tree *write_tree_from_memory(struct merge_options *o) 423{ 424struct tree *result = NULL; 425struct index_state *istate = o->repo->index; 426 427if(unmerged_index(istate)) { 428int i; 429fprintf(stderr,"BUG: There are unmerged index entries:\n"); 430for(i =0; i < istate->cache_nr; i++) { 431const struct cache_entry *ce = istate->cache[i]; 432if(ce_stage(ce)) 433fprintf(stderr,"BUG:%d%.*s\n",ce_stage(ce), 434(int)ce_namelen(ce), ce->name); 435} 436BUG("unmerged index entries in merge-recursive.c"); 437} 438 439if(!istate->cache_tree) 440 istate->cache_tree =cache_tree(); 441 442if(!cache_tree_fully_valid(istate->cache_tree) && 443cache_tree_update(istate,0) <0) { 444err(o,_("error building trees")); 445return NULL; 446} 447 448 result =lookup_tree(the_repository, &istate->cache_tree->oid); 449 450return result; 451} 452 453static intsave_files_dirs(const struct object_id *oid, 454struct strbuf *base,const char*path, 455unsigned int mode,int stage,void*context) 456{ 457struct path_hashmap_entry *entry; 458int baselen = base->len; 459struct merge_options *o = context; 460 461strbuf_addstr(base, path); 462 463FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 464hashmap_entry_init(entry,path_hash(entry->path)); 465hashmap_add(&o->current_file_dir_set, entry); 466 467strbuf_setlen(base, baselen); 468return(S_ISDIR(mode) ? READ_TREE_RECURSIVE :0); 469} 470 471static voidget_files_dirs(struct merge_options *o,struct tree *tree) 472{ 473struct pathspec match_all; 474memset(&match_all,0,sizeof(match_all)); 475read_tree_recursive(tree,"",0,0, &match_all, save_files_dirs, o); 476} 477 478static intget_tree_entry_if_blob(const struct object_id *tree, 479const char*path, 480struct object_id *hashy, 481unsigned int*mode_o) 482{ 483int ret; 484 485 ret =get_tree_entry(tree, path, hashy, mode_o); 486if(S_ISDIR(*mode_o)) { 487oidcpy(hashy, &null_oid); 488*mode_o =0; 489} 490return ret; 491} 492 493/* 494 * Returns an index_entry instance which doesn't have to correspond to 495 * a real cache entry in Git's index. 496 */ 497static struct stage_data *insert_stage_data(const char*path, 498struct tree *o,struct tree *a,struct tree *b, 499struct string_list *entries) 500{ 501struct string_list_item *item; 502struct stage_data *e =xcalloc(1,sizeof(struct stage_data)); 503get_tree_entry_if_blob(&o->object.oid, path, 504&e->stages[1].oid, &e->stages[1].mode); 505get_tree_entry_if_blob(&a->object.oid, path, 506&e->stages[2].oid, &e->stages[2].mode); 507get_tree_entry_if_blob(&b->object.oid, path, 508&e->stages[3].oid, &e->stages[3].mode); 509 item =string_list_insert(entries, path); 510 item->util = e; 511return e; 512} 513 514/* 515 * Create a dictionary mapping file names to stage_data objects. The 516 * dictionary contains one entry for every path with a non-zero stage entry. 517 */ 518static struct string_list *get_unmerged(struct index_state *istate) 519{ 520struct string_list *unmerged =xcalloc(1,sizeof(struct string_list)); 521int i; 522 523 unmerged->strdup_strings =1; 524 525for(i =0; i < istate->cache_nr; i++) { 526struct string_list_item *item; 527struct stage_data *e; 528const struct cache_entry *ce = istate->cache[i]; 529if(!ce_stage(ce)) 530continue; 531 532 item =string_list_lookup(unmerged, ce->name); 533if(!item) { 534 item =string_list_insert(unmerged, ce->name); 535 item->util =xcalloc(1,sizeof(struct stage_data)); 536} 537 e = item->util; 538 e->stages[ce_stage(ce)].mode = ce->ce_mode; 539oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 540} 541 542return unmerged; 543} 544 545static intstring_list_df_name_compare(const char*one,const char*two) 546{ 547int onelen =strlen(one); 548int twolen =strlen(two); 549/* 550 * Here we only care that entries for D/F conflicts are 551 * adjacent, in particular with the file of the D/F conflict 552 * appearing before files below the corresponding directory. 553 * The order of the rest of the list is irrelevant for us. 554 * 555 * To achieve this, we sort with df_name_compare and provide 556 * the mode S_IFDIR so that D/F conflicts will sort correctly. 557 * We use the mode S_IFDIR for everything else for simplicity, 558 * since in other cases any changes in their order due to 559 * sorting cause no problems for us. 560 */ 561int cmp =df_name_compare(one, onelen, S_IFDIR, 562 two, twolen, S_IFDIR); 563/* 564 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 565 * that 'foo' comes before 'foo/bar'. 566 */ 567if(cmp) 568return cmp; 569return onelen - twolen; 570} 571 572static voidrecord_df_conflict_files(struct merge_options *o, 573struct string_list *entries) 574{ 575/* If there is a D/F conflict and the file for such a conflict 576 * currently exists in the working tree, we want to allow it to be 577 * removed to make room for the corresponding directory if needed. 578 * The files underneath the directories of such D/F conflicts will 579 * be processed before the corresponding file involved in the D/F 580 * conflict. If the D/F directory ends up being removed by the 581 * merge, then we won't have to touch the D/F file. If the D/F 582 * directory needs to be written to the working copy, then the D/F 583 * file will simply be removed (in make_room_for_path()) to make 584 * room for the necessary paths. Note that if both the directory 585 * and the file need to be present, then the D/F file will be 586 * reinstated with a new unique name at the time it is processed. 587 */ 588struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 589const char*last_file = NULL; 590int last_len =0; 591int i; 592 593/* 594 * If we're merging merge-bases, we don't want to bother with 595 * any working directory changes. 596 */ 597if(o->call_depth) 598return; 599 600/* Ensure D/F conflicts are adjacent in the entries list. */ 601for(i =0; i < entries->nr; i++) { 602struct string_list_item *next = &entries->items[i]; 603string_list_append(&df_sorted_entries, next->string)->util = 604 next->util; 605} 606 df_sorted_entries.cmp = string_list_df_name_compare; 607string_list_sort(&df_sorted_entries); 608 609string_list_clear(&o->df_conflict_file_set,1); 610for(i =0; i < df_sorted_entries.nr; i++) { 611const char*path = df_sorted_entries.items[i].string; 612int len =strlen(path); 613struct stage_data *e = df_sorted_entries.items[i].util; 614 615/* 616 * Check if last_file & path correspond to a D/F conflict; 617 * i.e. whether path is last_file+'/'+<something>. 618 * If so, record that it's okay to remove last_file to make 619 * room for path and friends if needed. 620 */ 621if(last_file && 622 len > last_len && 623memcmp(path, last_file, last_len) ==0&& 624 path[last_len] =='/') { 625string_list_insert(&o->df_conflict_file_set, last_file); 626} 627 628/* 629 * Determine whether path could exist as a file in the 630 * working directory as a possible D/F conflict. This 631 * will only occur when it exists in stage 2 as a 632 * file. 633 */ 634if(S_ISREG(e->stages[2].mode) ||S_ISLNK(e->stages[2].mode)) { 635 last_file = path; 636 last_len = len; 637}else{ 638 last_file = NULL; 639} 640} 641string_list_clear(&df_sorted_entries,0); 642} 643 644struct rename { 645struct diff_filepair *pair; 646/* 647 * Purpose of src_entry and dst_entry: 648 * 649 * If 'before' is renamed to 'after' then src_entry will contain 650 * the versions of 'before' from the merge_base, HEAD, and MERGE in 651 * stages 1, 2, and 3; dst_entry will contain the respective 652 * versions of 'after' in corresponding locations. Thus, we have a 653 * total of six modes and oids, though some will be null. (Stage 0 654 * is ignored; we're interested in handling conflicts.) 655 * 656 * Since we don't turn on break-rewrites by default, neither 657 * src_entry nor dst_entry can have all three of their stages have 658 * non-null oids, meaning at most four of the six will be non-null. 659 * Also, since this is a rename, both src_entry and dst_entry will 660 * have at least one non-null oid, meaning at least two will be 661 * non-null. Of the six oids, a typical rename will have three be 662 * non-null. Only two implies a rename/delete, and four implies a 663 * rename/add. 664 */ 665struct stage_data *src_entry; 666struct stage_data *dst_entry; 667unsigned add_turned_into_rename:1; 668unsigned processed:1; 669}; 670 671static intupdate_stages(struct merge_options *opt,const char*path, 672const struct diff_filespec *o, 673const struct diff_filespec *a, 674const struct diff_filespec *b) 675{ 676 677/* 678 * NOTE: It is usually a bad idea to call update_stages on a path 679 * before calling update_file on that same path, since it can 680 * sometimes lead to spurious "refusing to lose untracked file..." 681 * messages from update_file (via make_room_for path via 682 * would_lose_untracked). Instead, reverse the order of the calls 683 * (executing update_file first and then update_stages). 684 */ 685int clear =1; 686int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 687if(clear) 688if(remove_file_from_index(opt->repo->index, path)) 689return-1; 690if(o) 691if(add_cacheinfo(opt, o->mode, &o->oid, path,1,0, options)) 692return-1; 693if(a) 694if(add_cacheinfo(opt, a->mode, &a->oid, path,2,0, options)) 695return-1; 696if(b) 697if(add_cacheinfo(opt, b->mode, &b->oid, path,3,0, options)) 698return-1; 699return0; 700} 701 702static voidupdate_entry(struct stage_data *entry, 703struct diff_filespec *o, 704struct diff_filespec *a, 705struct diff_filespec *b) 706{ 707 entry->processed =0; 708 entry->stages[1].mode = o->mode; 709 entry->stages[2].mode = a->mode; 710 entry->stages[3].mode = b->mode; 711oidcpy(&entry->stages[1].oid, &o->oid); 712oidcpy(&entry->stages[2].oid, &a->oid); 713oidcpy(&entry->stages[3].oid, &b->oid); 714} 715 716static intremove_file(struct merge_options *o,int clean, 717const char*path,int no_wd) 718{ 719int update_cache = o->call_depth || clean; 720int update_working_directory = !o->call_depth && !no_wd; 721 722if(update_cache) { 723if(remove_file_from_index(o->repo->index, path)) 724return-1; 725} 726if(update_working_directory) { 727if(ignore_case) { 728struct cache_entry *ce; 729 ce =index_file_exists(o->repo->index, path,strlen(path), 730 ignore_case); 731if(ce &&ce_stage(ce) ==0&&strcmp(path, ce->name)) 732return0; 733} 734if(remove_path(path)) 735return-1; 736} 737return0; 738} 739 740/* add a string to a strbuf, but converting "/" to "_" */ 741static voidadd_flattened_path(struct strbuf *out,const char*s) 742{ 743size_t i = out->len; 744strbuf_addstr(out, s); 745for(; i < out->len; i++) 746if(out->buf[i] =='/') 747 out->buf[i] ='_'; 748} 749 750static char*unique_path(struct merge_options *o,const char*path,const char*branch) 751{ 752struct path_hashmap_entry *entry; 753struct strbuf newpath = STRBUF_INIT; 754int suffix =0; 755size_t base_len; 756 757strbuf_addf(&newpath,"%s~", path); 758add_flattened_path(&newpath, branch); 759 760 base_len = newpath.len; 761while(hashmap_get_from_hash(&o->current_file_dir_set, 762path_hash(newpath.buf), newpath.buf) || 763(!o->call_depth &&file_exists(newpath.buf))) { 764strbuf_setlen(&newpath, base_len); 765strbuf_addf(&newpath,"_%d", suffix++); 766} 767 768FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 769hashmap_entry_init(entry,path_hash(entry->path)); 770hashmap_add(&o->current_file_dir_set, entry); 771returnstrbuf_detach(&newpath, NULL); 772} 773 774/** 775 * Check whether a directory in the index is in the way of an incoming 776 * file. Return 1 if so. If check_working_copy is non-zero, also 777 * check the working directory. If empty_ok is non-zero, also return 778 * 0 in the case where the working-tree dir exists but is empty. 779 */ 780static intdir_in_way(struct index_state *istate,const char*path, 781int check_working_copy,int empty_ok) 782{ 783int pos; 784struct strbuf dirpath = STRBUF_INIT; 785struct stat st; 786 787strbuf_addstr(&dirpath, path); 788strbuf_addch(&dirpath,'/'); 789 790 pos =index_name_pos(istate, dirpath.buf, dirpath.len); 791 792if(pos <0) 793 pos = -1- pos; 794if(pos < istate->cache_nr && 795!strncmp(dirpath.buf, istate->cache[pos]->name, dirpath.len)) { 796strbuf_release(&dirpath); 797return1; 798} 799 800strbuf_release(&dirpath); 801return check_working_copy && !lstat(path, &st) &&S_ISDIR(st.st_mode) && 802!(empty_ok &&is_empty_dir(path)); 803} 804 805/* 806 * Returns whether path was tracked in the index before the merge started, 807 * and its oid and mode match the specified values 808 */ 809static intwas_tracked_and_matches(struct merge_options *o,const char*path, 810const struct object_id *oid,unsigned mode) 811{ 812int pos =index_name_pos(&o->orig_index, path,strlen(path)); 813struct cache_entry *ce; 814 815if(0> pos) 816/* we were not tracking this path before the merge */ 817return0; 818 819/* See if the file we were tracking before matches */ 820 ce = o->orig_index.cache[pos]; 821return(oid_eq(&ce->oid, oid) && ce->ce_mode == mode); 822} 823 824/* 825 * Returns whether path was tracked in the index before the merge started 826 */ 827static intwas_tracked(struct merge_options *o,const char*path) 828{ 829int pos =index_name_pos(&o->orig_index, path,strlen(path)); 830 831if(0<= pos) 832/* we were tracking this path before the merge */ 833return1; 834 835return0; 836} 837 838static intwould_lose_untracked(struct merge_options *o,const char*path) 839{ 840struct index_state *istate = o->repo->index; 841 842/* 843 * This may look like it can be simplified to: 844 * return !was_tracked(o, path) && file_exists(path) 845 * but it can't. This function needs to know whether path was in 846 * the working tree due to EITHER having been tracked in the index 847 * before the merge OR having been put into the working copy and 848 * index by unpack_trees(). Due to that either-or requirement, we 849 * check the current index instead of the original one. 850 * 851 * Note that we do not need to worry about merge-recursive itself 852 * updating the index after unpack_trees() and before calling this 853 * function, because we strictly require all code paths in 854 * merge-recursive to update the working tree first and the index 855 * second. Doing otherwise would break 856 * update_file()/would_lose_untracked(); see every comment in this 857 * file which mentions "update_stages". 858 */ 859int pos =index_name_pos(istate, path,strlen(path)); 860 861if(pos <0) 862 pos = -1- pos; 863while(pos < istate->cache_nr && 864!strcmp(path, istate->cache[pos]->name)) { 865/* 866 * If stage #0, it is definitely tracked. 867 * If it has stage #2 then it was tracked 868 * before this merge started. All other 869 * cases the path was not tracked. 870 */ 871switch(ce_stage(istate->cache[pos])) { 872case0: 873case2: 874return0; 875} 876 pos++; 877} 878returnfile_exists(path); 879} 880 881static intwas_dirty(struct merge_options *o,const char*path) 882{ 883struct cache_entry *ce; 884int dirty =1; 885 886if(o->call_depth || !was_tracked(o, path)) 887return!dirty; 888 889 ce =index_file_exists(o->unpack_opts.src_index, 890 path,strlen(path), ignore_case); 891 dirty =verify_uptodate(ce, &o->unpack_opts) !=0; 892return dirty; 893} 894 895static intmake_room_for_path(struct merge_options *o,const char*path) 896{ 897int status, i; 898const char*msg =_("failed to create path '%s'%s"); 899 900/* Unlink any D/F conflict files that are in the way */ 901for(i =0; i < o->df_conflict_file_set.nr; i++) { 902const char*df_path = o->df_conflict_file_set.items[i].string; 903size_t pathlen =strlen(path); 904size_t df_pathlen =strlen(df_path); 905if(df_pathlen < pathlen && 906 path[df_pathlen] =='/'&& 907strncmp(path, df_path, df_pathlen) ==0) { 908output(o,3, 909_("Removing%sto make room for subdirectory\n"), 910 df_path); 911unlink(df_path); 912unsorted_string_list_delete_item(&o->df_conflict_file_set, 913 i,0); 914break; 915} 916} 917 918/* Make sure leading directories are created */ 919 status =safe_create_leading_directories_const(path); 920if(status) { 921if(status == SCLD_EXISTS) 922/* something else exists */ 923returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 924returnerr(o, msg, path,""); 925} 926 927/* 928 * Do not unlink a file in the work tree if we are not 929 * tracking it. 930 */ 931if(would_lose_untracked(o, path)) 932returnerr(o,_("refusing to lose untracked file at '%s'"), 933 path); 934 935/* Successful unlink is good.. */ 936if(!unlink(path)) 937return0; 938/* .. and so is no existing file */ 939if(errno == ENOENT) 940return0; 941/* .. but not some other error (who really cares what?) */ 942returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 943} 944 945static intupdate_file_flags(struct merge_options *o, 946const struct object_id *oid, 947unsigned mode, 948const char*path, 949int update_cache, 950int update_wd) 951{ 952int ret =0; 953 954if(o->call_depth) 955 update_wd =0; 956 957if(update_wd) { 958enum object_type type; 959void*buf; 960unsigned long size; 961 962if(S_ISGITLINK(mode)) { 963/* 964 * We may later decide to recursively descend into 965 * the submodule directory and update its index 966 * and/or work tree, but we do not do that now. 967 */ 968 update_wd =0; 969goto update_index; 970} 971 972 buf =read_object_file(oid, &type, &size); 973if(!buf) 974returnerr(o,_("cannot read object%s'%s'"),oid_to_hex(oid), path); 975if(type != OBJ_BLOB) { 976 ret =err(o,_("blob expected for%s'%s'"),oid_to_hex(oid), path); 977goto free_buf; 978} 979if(S_ISREG(mode)) { 980struct strbuf strbuf = STRBUF_INIT; 981if(convert_to_working_tree(o->repo->index, path, buf, size, &strbuf)) { 982free(buf); 983 size = strbuf.len; 984 buf =strbuf_detach(&strbuf, NULL); 985} 986} 987 988if(make_room_for_path(o, path) <0) { 989 update_wd =0; 990goto free_buf; 991} 992if(S_ISREG(mode) || (!has_symlinks &&S_ISLNK(mode))) { 993int fd; 994if(mode &0100) 995 mode =0777; 996else 997 mode =0666; 998 fd =open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 999if(fd <0) {1000 ret =err(o,_("failed to open '%s':%s"),1001 path,strerror(errno));1002goto free_buf;1003}1004write_in_full(fd, buf, size);1005close(fd);1006}else if(S_ISLNK(mode)) {1007char*lnk =xmemdupz(buf, size);1008safe_create_leading_directories_const(path);1009unlink(path);1010if(symlink(lnk, path))1011 ret =err(o,_("failed to symlink '%s':%s"),1012 path,strerror(errno));1013free(lnk);1014}else1015 ret =err(o,1016_("do not know what to do with%06o%s'%s'"),1017 mode,oid_to_hex(oid), path);1018 free_buf:1019free(buf);1020}1021update_index:1022if(!ret && update_cache)1023if(add_cacheinfo(o, mode, oid, path,0, update_wd,1024 ADD_CACHE_OK_TO_ADD))1025return-1;1026return ret;1027}10281029static intupdate_file(struct merge_options *o,1030int clean,1031const struct object_id *oid,1032unsigned mode,1033const char*path)1034{1035returnupdate_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth);1036}10371038/* Low level file merging, update and removal */10391040struct merge_file_info {1041struct object_id oid;1042unsigned mode;1043unsigned clean:1,1044 merge:1;1045};10461047static intmerge_3way(struct merge_options *o,1048 mmbuffer_t *result_buf,1049const struct diff_filespec *one,1050const struct diff_filespec *a,1051const struct diff_filespec *b,1052const char*branch1,1053const char*branch2,1054const int extra_marker_size)1055{1056 mmfile_t orig, src1, src2;1057struct ll_merge_options ll_opts = {0};1058char*base_name, *name1, *name2;1059int merge_status;10601061 ll_opts.renormalize = o->renormalize;1062 ll_opts.extra_marker_size = extra_marker_size;1063 ll_opts.xdl_opts = o->xdl_opts;10641065if(o->call_depth) {1066 ll_opts.virtual_ancestor =1;1067 ll_opts.variant =0;1068}else{1069switch(o->recursive_variant) {1070case MERGE_RECURSIVE_OURS:1071 ll_opts.variant = XDL_MERGE_FAVOR_OURS;1072break;1073case MERGE_RECURSIVE_THEIRS:1074 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;1075break;1076default:1077 ll_opts.variant =0;1078break;1079}1080}10811082if(strcmp(a->path, b->path) ||1083(o->ancestor != NULL &&strcmp(a->path, one->path) !=0)) {1084 base_name = o->ancestor == NULL ? NULL :1085mkpathdup("%s:%s", o->ancestor, one->path);1086 name1 =mkpathdup("%s:%s", branch1, a->path);1087 name2 =mkpathdup("%s:%s", branch2, b->path);1088}else{1089 base_name = o->ancestor == NULL ? NULL :1090mkpathdup("%s", o->ancestor);1091 name1 =mkpathdup("%s", branch1);1092 name2 =mkpathdup("%s", branch2);1093}10941095read_mmblob(&orig, &one->oid);1096read_mmblob(&src1, &a->oid);1097read_mmblob(&src2, &b->oid);10981099 merge_status =ll_merge(result_buf, a->path, &orig, base_name,1100&src1, name1, &src2, name2,1101 o->repo->index, &ll_opts);11021103free(base_name);1104free(name1);1105free(name2);1106free(orig.ptr);1107free(src1.ptr);1108free(src2.ptr);1109return merge_status;1110}11111112static intfind_first_merges(struct repository *repo,1113struct object_array *result,const char*path,1114struct commit *a,struct commit *b)1115{1116int i, j;1117struct object_array merges = OBJECT_ARRAY_INIT;1118struct commit *commit;1119int contains_another;11201121char merged_revision[42];1122const char*rev_args[] = {"rev-list","--merges","--ancestry-path",1123"--all", merged_revision, NULL };1124struct rev_info revs;1125struct setup_revision_opt rev_opts;11261127memset(result,0,sizeof(struct object_array));1128memset(&rev_opts,0,sizeof(rev_opts));11291130/* get all revisions that merge commit a */1131xsnprintf(merged_revision,sizeof(merged_revision),"^%s",1132oid_to_hex(&a->object.oid));1133repo_init_revisions(repo, &revs, NULL);1134 rev_opts.submodule = path;1135/* FIXME: can't handle linked worktrees in submodules yet */1136 revs.single_worktree = path != NULL;1137setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);11381139/* save all revisions from the above list that contain b */1140if(prepare_revision_walk(&revs))1141die("revision walk setup failed");1142while((commit =get_revision(&revs)) != NULL) {1143struct object *o = &(commit->object);1144if(in_merge_bases(b, commit))1145add_object_array(o, NULL, &merges);1146}1147reset_revision_walk();11481149/* Now we've got all merges that contain a and b. Prune all1150 * merges that contain another found merge and save them in1151 * result.1152 */1153for(i =0; i < merges.nr; i++) {1154struct commit *m1 = (struct commit *) merges.objects[i].item;11551156 contains_another =0;1157for(j =0; j < merges.nr; j++) {1158struct commit *m2 = (struct commit *) merges.objects[j].item;1159if(i != j &&in_merge_bases(m2, m1)) {1160 contains_another =1;1161break;1162}1163}11641165if(!contains_another)1166add_object_array(merges.objects[i].item, NULL, result);1167}11681169object_array_clear(&merges);1170return result->nr;1171}11721173static voidprint_commit(struct commit *commit)1174{1175struct strbuf sb = STRBUF_INIT;1176struct pretty_print_context ctx = {0};1177 ctx.date_mode.type = DATE_NORMAL;1178format_commit_message(commit,"%h:%m %s", &sb, &ctx);1179fprintf(stderr,"%s\n", sb.buf);1180strbuf_release(&sb);1181}11821183static intmerge_submodule(struct merge_options *o,1184struct object_id *result,const char*path,1185const struct object_id *base,const struct object_id *a,1186const struct object_id *b)1187{1188struct commit *commit_base, *commit_a, *commit_b;1189int parent_count;1190struct object_array merges;11911192int i;1193int search = !o->call_depth;11941195/* store a in result in case we fail */1196oidcpy(result, a);11971198/* we can not handle deletion conflicts */1199if(is_null_oid(base))1200return0;1201if(is_null_oid(a))1202return0;1203if(is_null_oid(b))1204return0;12051206if(add_submodule_odb(path)) {1207output(o,1,_("Failed to merge submodule%s(not checked out)"), path);1208return0;1209}12101211if(!(commit_base =lookup_commit_reference(the_repository, base)) ||1212!(commit_a =lookup_commit_reference(the_repository, a)) ||1213!(commit_b =lookup_commit_reference(the_repository, b))) {1214output(o,1,_("Failed to merge submodule%s(commits not present)"), path);1215return0;1216}12171218/* check whether both changes are forward */1219if(!in_merge_bases(commit_base, commit_a) ||1220!in_merge_bases(commit_base, commit_b)) {1221output(o,1,_("Failed to merge submodule%s(commits don't follow merge-base)"), path);1222return0;1223}12241225/* Case #1: a is contained in b or vice versa */1226if(in_merge_bases(commit_a, commit_b)) {1227oidcpy(result, b);1228if(show(o,3)) {1229output(o,3,_("Fast-forwarding submodule%sto the following commit:"), path);1230output_commit_title(o, commit_b);1231}else if(show(o,2))1232output(o,2,_("Fast-forwarding submodule%s"), path);1233else1234;/* no output */12351236return1;1237}1238if(in_merge_bases(commit_b, commit_a)) {1239oidcpy(result, a);1240if(show(o,3)) {1241output(o,3,_("Fast-forwarding submodule%sto the following commit:"), path);1242output_commit_title(o, commit_a);1243}else if(show(o,2))1244output(o,2,_("Fast-forwarding submodule%s"), path);1245else1246;/* no output */12471248return1;1249}12501251/*1252 * Case #2: There are one or more merges that contain a and b in1253 * the submodule. If there is only one, then present it as a1254 * suggestion to the user, but leave it marked unmerged so the1255 * user needs to confirm the resolution.1256 */12571258/* Skip the search if makes no sense to the calling context. */1259if(!search)1260return0;12611262/* find commit which merges them */1263 parent_count =find_first_merges(o->repo, &merges, path,1264 commit_a, commit_b);1265switch(parent_count) {1266case0:1267output(o,1,_("Failed to merge submodule%s(merge following commits not found)"), path);1268break;12691270case1:1271output(o,1,_("Failed to merge submodule%s(not fast-forward)"), path);1272output(o,2,_("Found a possible merge resolution for the submodule:\n"));1273print_commit((struct commit *) merges.objects[0].item);1274output(o,2,_(1275"If this is correct simply add it to the index "1276"for example\n"1277"by using:\n\n"1278" git update-index --cacheinfo 160000%s\"%s\"\n\n"1279"which will accept this suggestion.\n"),1280oid_to_hex(&merges.objects[0].item->oid), path);1281break;12821283default:1284output(o,1,_("Failed to merge submodule%s(multiple merges found)"), path);1285for(i =0; i < merges.nr; i++)1286print_commit((struct commit *) merges.objects[i].item);1287}12881289object_array_clear(&merges);1290return0;1291}12921293static intmerge_mode_and_contents(struct merge_options *o,1294const struct diff_filespec *one,1295const struct diff_filespec *a,1296const struct diff_filespec *b,1297const char*filename,1298const char*branch1,1299const char*branch2,1300const int extra_marker_size,1301struct merge_file_info *result)1302{1303if(o->branch1 != branch1) {1304/*1305 * It's weird getting a reverse merge with HEAD on the bottom1306 * side of the conflict markers and the other branch on the1307 * top. Fix that.1308 */1309returnmerge_mode_and_contents(o, one, b, a,1310 filename,1311 branch2, branch1,1312 extra_marker_size, result);1313}13141315 result->merge =0;1316 result->clean =1;13171318if((S_IFMT & a->mode) != (S_IFMT & b->mode)) {1319 result->clean =0;1320if(S_ISREG(a->mode)) {1321 result->mode = a->mode;1322oidcpy(&result->oid, &a->oid);1323}else{1324 result->mode = b->mode;1325oidcpy(&result->oid, &b->oid);1326}1327}else{1328if(!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))1329 result->merge =1;13301331/*1332 * Merge modes1333 */1334if(a->mode == b->mode || a->mode == one->mode)1335 result->mode = b->mode;1336else{1337 result->mode = a->mode;1338if(b->mode != one->mode) {1339 result->clean =0;1340 result->merge =1;1341}1342}13431344if(oid_eq(&a->oid, &b->oid) ||oid_eq(&a->oid, &one->oid))1345oidcpy(&result->oid, &b->oid);1346else if(oid_eq(&b->oid, &one->oid))1347oidcpy(&result->oid, &a->oid);1348else if(S_ISREG(a->mode)) {1349 mmbuffer_t result_buf;1350int ret =0, merge_status;13511352 merge_status =merge_3way(o, &result_buf, one, a, b,1353 branch1, branch2,1354 extra_marker_size);13551356if((merge_status <0) || !result_buf.ptr)1357 ret =err(o,_("Failed to execute internal merge"));13581359if(!ret &&1360write_object_file(result_buf.ptr, result_buf.size,1361 blob_type, &result->oid))1362 ret =err(o,_("Unable to add%sto database"),1363 a->path);13641365free(result_buf.ptr);1366if(ret)1367return ret;1368 result->clean = (merge_status ==0);1369}else if(S_ISGITLINK(a->mode)) {1370 result->clean =merge_submodule(o, &result->oid,1371 one->path,1372&one->oid,1373&a->oid,1374&b->oid);1375}else if(S_ISLNK(a->mode)) {1376switch(o->recursive_variant) {1377case MERGE_RECURSIVE_NORMAL:1378oidcpy(&result->oid, &a->oid);1379if(!oid_eq(&a->oid, &b->oid))1380 result->clean =0;1381break;1382case MERGE_RECURSIVE_OURS:1383oidcpy(&result->oid, &a->oid);1384break;1385case MERGE_RECURSIVE_THEIRS:1386oidcpy(&result->oid, &b->oid);1387break;1388}1389}else1390BUG("unsupported object type in the tree");1391}13921393if(result->merge)1394output(o,2,_("Auto-merging%s"), filename);13951396return0;1397}13981399static inthandle_rename_via_dir(struct merge_options *o,1400struct diff_filepair *pair,1401const char*rename_branch,1402const char*other_branch)1403{1404/*1405 * Handle file adds that need to be renamed due to directory rename1406 * detection. This differs from handle_rename_normal, because1407 * there is no content merge to do; just move the file into the1408 * desired final location.1409 */1410const struct diff_filespec *dest = pair->two;14111412if(!o->call_depth &&would_lose_untracked(o, dest->path)) {1413char*alt_path =unique_path(o, dest->path, rename_branch);14141415output(o,1,_("Error: Refusing to lose untracked file at%s; "1416"writing to%sinstead."),1417 dest->path, alt_path);1418/*1419 * Write the file in worktree at alt_path, but not in the1420 * index. Instead, write to dest->path for the index but1421 * only at the higher appropriate stage.1422 */1423if(update_file(o,0, &dest->oid, dest->mode, alt_path))1424return-1;1425free(alt_path);1426returnupdate_stages(o, dest->path, NULL,1427 rename_branch == o->branch1 ? dest : NULL,1428 rename_branch == o->branch1 ? NULL : dest);1429}14301431/* Update dest->path both in index and in worktree */1432if(update_file(o,1, &dest->oid, dest->mode, dest->path))1433return-1;1434return0;1435}14361437static inthandle_change_delete(struct merge_options *o,1438const char*path,const char*old_path,1439const struct object_id *o_oid,int o_mode,1440const struct object_id *changed_oid,1441int changed_mode,1442const char*change_branch,1443const char*delete_branch,1444const char*change,const char*change_past)1445{1446char*alt_path = NULL;1447const char*update_path = path;1448int ret =0;14491450if(dir_in_way(o->repo->index, path, !o->call_depth,0) ||1451(!o->call_depth &&would_lose_untracked(o, path))) {1452 update_path = alt_path =unique_path(o, path, change_branch);1453}14541455if(o->call_depth) {1456/*1457 * We cannot arbitrarily accept either a_sha or b_sha as1458 * correct; since there is no true "middle point" between1459 * them, simply reuse the base version for virtual merge base.1460 */1461 ret =remove_file_from_index(o->repo->index, path);1462if(!ret)1463 ret =update_file(o,0, o_oid, o_mode, update_path);1464}else{1465/*1466 * Despite the four nearly duplicate messages and argument1467 * lists below and the ugliness of the nested if-statements,1468 * having complete messages makes the job easier for1469 * translators.1470 *1471 * The slight variance among the cases is due to the fact1472 * that:1473 * 1) directory/file conflicts (in effect if1474 * !alt_path) could cause us to need to write the1475 * file to a different path.1476 * 2) renames (in effect if !old_path) could mean that1477 * there are two names for the path that the user1478 * may know the file by.1479 */1480if(!alt_path) {1481if(!old_path) {1482output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1483"and%sin%s. Version%sof%sleft in tree."),1484 change, path, delete_branch, change_past,1485 change_branch, change_branch, path);1486}else{1487output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1488"and%sto%sin%s. Version%sof%sleft in tree."),1489 change, old_path, delete_branch, change_past, path,1490 change_branch, change_branch, path);1491}1492}else{1493if(!old_path) {1494output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1495"and%sin%s. Version%sof%sleft in tree at%s."),1496 change, path, delete_branch, change_past,1497 change_branch, change_branch, path, alt_path);1498}else{1499output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1500"and%sto%sin%s. Version%sof%sleft in tree at%s."),1501 change, old_path, delete_branch, change_past, path,1502 change_branch, change_branch, path, alt_path);1503}1504}1505/*1506 * No need to call update_file() on path when change_branch ==1507 * o->branch1 && !alt_path, since that would needlessly touch1508 * path. We could call update_file_flags() with update_cache=01509 * and update_wd=0, but that's a no-op.1510 */1511if(change_branch != o->branch1 || alt_path)1512 ret =update_file(o,0, changed_oid, changed_mode, update_path);1513}1514free(alt_path);15151516return ret;1517}15181519static inthandle_rename_delete(struct merge_options *o,1520struct diff_filepair *pair,1521const char*rename_branch,1522const char*delete_branch)1523{1524const struct diff_filespec *orig = pair->one;1525const struct diff_filespec *dest = pair->two;15261527if(handle_change_delete(o,1528 o->call_depth ? orig->path : dest->path,1529 o->call_depth ? NULL : orig->path,1530&orig->oid, orig->mode,1531&dest->oid, dest->mode,1532 rename_branch, delete_branch,1533_("rename"),_("renamed")))1534return-1;15351536if(o->call_depth)1537returnremove_file_from_index(o->repo->index, dest->path);1538else1539returnupdate_stages(o, dest->path, NULL,1540 rename_branch == o->branch1 ? dest : NULL,1541 rename_branch == o->branch1 ? NULL : dest);1542}15431544static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,1545struct stage_data *entry,1546int stage)1547{1548struct object_id *oid = &entry->stages[stage].oid;1549unsigned mode = entry->stages[stage].mode;1550if(mode ==0||is_null_oid(oid))1551return NULL;1552oidcpy(&target->oid, oid);1553 target->mode = mode;1554return target;1555}15561557static inthandle_file_collision(struct merge_options *o,1558const char*collide_path,1559const char*prev_path1,1560const char*prev_path2,1561const char*branch1,const char*branch2,1562const struct object_id *a_oid,1563unsigned int a_mode,1564const struct object_id *b_oid,1565unsigned int b_mode)1566{1567struct merge_file_info mfi;1568struct diff_filespec null, a, b;1569char*alt_path = NULL;1570const char*update_path = collide_path;15711572/*1573 * It's easiest to get the correct things into stage 2 and 3, and1574 * to make sure that the content merge puts HEAD before the other1575 * branch if we just ensure that branch1 == o->branch1. So, simply1576 * flip arguments around if we don't have that.1577 */1578if(branch1 != o->branch1) {1579returnhandle_file_collision(o, collide_path,1580 prev_path2, prev_path1,1581 branch2, branch1,1582 b_oid, b_mode,1583 a_oid, a_mode);1584}15851586/*1587 * In the recursive case, we just opt to undo renames1588 */1589if(o->call_depth && (prev_path1 || prev_path2)) {1590/* Put first file (a_oid, a_mode) in its original spot */1591if(prev_path1) {1592if(update_file(o,1, a_oid, a_mode, prev_path1))1593return-1;1594}else{1595if(update_file(o,1, a_oid, a_mode, collide_path))1596return-1;1597}15981599/* Put second file (b_oid, b_mode) in its original spot */1600if(prev_path2) {1601if(update_file(o,1, b_oid, b_mode, prev_path2))1602return-1;1603}else{1604if(update_file(o,1, b_oid, b_mode, collide_path))1605return-1;1606}16071608/* Don't leave something at collision path if unrenaming both */1609if(prev_path1 && prev_path2)1610remove_file(o,1, collide_path,0);16111612return0;1613}16141615/* Remove rename sources if rename/add or rename/rename(2to1) */1616if(prev_path1)1617remove_file(o,1, prev_path1,1618 o->call_depth ||would_lose_untracked(o, prev_path1));1619if(prev_path2)1620remove_file(o,1, prev_path2,1621 o->call_depth ||would_lose_untracked(o, prev_path2));16221623/*1624 * Remove the collision path, if it wouldn't cause dirty contents1625 * or an untracked file to get lost. We'll either overwrite with1626 * merged contents, or just write out to differently named files.1627 */1628if(was_dirty(o, collide_path)) {1629output(o,1,_("Refusing to lose dirty file at%s"),1630 collide_path);1631 update_path = alt_path =unique_path(o, collide_path,"merged");1632}else if(would_lose_untracked(o, collide_path)) {1633/*1634 * Only way we get here is if both renames were from1635 * a directory rename AND user had an untracked file1636 * at the location where both files end up after the1637 * two directory renames. See testcase 10d of t6043.1638 */1639output(o,1,_("Refusing to lose untracked file at "1640"%s, even though it's in the way."),1641 collide_path);1642 update_path = alt_path =unique_path(o, collide_path,"merged");1643}else{1644/*1645 * FIXME: It's possible that the two files are identical1646 * and that the current working copy happens to match, in1647 * which case we are unnecessarily touching the working1648 * tree file. It's not a likely enough scenario that I1649 * want to code up the checks for it and a better fix is1650 * available if we restructure how unpack_trees() and1651 * merge-recursive interoperate anyway, so punting for1652 * now...1653 */1654remove_file(o,0, collide_path,0);1655}16561657/* Store things in diff_filespecs for functions that need it */1658memset(&a,0,sizeof(struct diff_filespec));1659memset(&b,0,sizeof(struct diff_filespec));1660 null.path = a.path = b.path = (char*)collide_path;1661oidcpy(&null.oid, &null_oid);1662 null.mode =0;1663oidcpy(&a.oid, a_oid);1664 a.mode = a_mode;1665 a.oid_valid =1;1666oidcpy(&b.oid, b_oid);1667 b.mode = b_mode;1668 b.oid_valid =1;16691670if(merge_mode_and_contents(o, &null, &a, &b, collide_path,1671 branch1, branch2, o->call_depth *2, &mfi))1672return-1;1673 mfi.clean &= !alt_path;1674if(update_file(o, mfi.clean, &mfi.oid, mfi.mode, update_path))1675return-1;1676if(!mfi.clean && !o->call_depth &&1677update_stages(o, collide_path, NULL, &a, &b))1678return-1;1679free(alt_path);1680/*1681 * FIXME: If both a & b both started with conflicts (only possible1682 * if they came from a rename/rename(2to1)), but had IDENTICAL1683 * contents including those conflicts, then in the next line we claim1684 * it was clean. If someone cares about this case, we should have the1685 * caller notify us if we started with conflicts.1686 */1687return mfi.clean;1688}16891690static inthandle_rename_add(struct merge_options *o,1691struct rename_conflict_info *ci)1692{1693/* a was renamed to c, and a separate c was added. */1694struct diff_filespec *a = ci->pair1->one;1695struct diff_filespec *c = ci->pair1->two;1696char*path = c->path;1697char*prev_path_desc;1698struct merge_file_info mfi;16991700int other_stage = (ci->branch1 == o->branch1 ?3:2);17011702output(o,1,_("CONFLICT (rename/add): "1703"Rename%s->%sin%s. Added%sin%s"),1704 a->path, c->path, ci->branch1,1705 c->path, ci->branch2);17061707 prev_path_desc =xstrfmt("version of%sfrom%s", path, a->path);1708if(merge_mode_and_contents(o, a, c, &ci->ren1_other, prev_path_desc,1709 o->branch1, o->branch2,17101+ o->call_depth *2, &mfi))1711return-1;1712free(prev_path_desc);17131714returnhandle_file_collision(o,1715 c->path, a->path, NULL,1716 ci->branch1, ci->branch2,1717&mfi.oid, mfi.mode,1718&ci->dst_entry1->stages[other_stage].oid,1719 ci->dst_entry1->stages[other_stage].mode);1720}17211722static char*find_path_for_conflict(struct merge_options *o,1723const char*path,1724const char*branch1,1725const char*branch2)1726{1727char*new_path = NULL;1728if(dir_in_way(o->repo->index, path, !o->call_depth,0)) {1729 new_path =unique_path(o, path, branch1);1730output(o,1,_("%sis a directory in%sadding "1731"as%sinstead"),1732 path, branch2, new_path);1733}else if(would_lose_untracked(o, path)) {1734 new_path =unique_path(o, path, branch1);1735output(o,1,_("Refusing to lose untracked file"1736" at%s; adding as%sinstead"),1737 path, new_path);1738}17391740return new_path;1741}17421743static inthandle_rename_rename_1to2(struct merge_options *o,1744struct rename_conflict_info *ci)1745{1746/* One file was renamed in both branches, but to different names. */1747struct merge_file_info mfi;1748struct diff_filespec other;1749struct diff_filespec *add;1750struct diff_filespec *one = ci->pair1->one;1751struct diff_filespec *a = ci->pair1->two;1752struct diff_filespec *b = ci->pair2->two;1753char*path_desc;17541755output(o,1,_("CONFLICT (rename/rename): "1756"Rename\"%s\"->\"%s\"in branch\"%s\""1757"rename\"%s\"->\"%s\"in\"%s\"%s"),1758 one->path, a->path, ci->branch1,1759 one->path, b->path, ci->branch2,1760 o->call_depth ?_(" (left unresolved)") :"");17611762 path_desc =xstrfmt("%sand%s, both renamed from%s",1763 a->path, b->path, one->path);1764if(merge_mode_and_contents(o, one, a, b, path_desc,1765 ci->branch1, ci->branch2,1766 o->call_depth *2, &mfi))1767return-1;1768free(path_desc);17691770if(o->call_depth) {1771/*1772 * FIXME: For rename/add-source conflicts (if we could detect1773 * such), this is wrong. We should instead find a unique1774 * pathname and then either rename the add-source file to that1775 * unique path, or use that unique path instead of src here.1776 */1777if(update_file(o,0, &mfi.oid, mfi.mode, one->path))1778return-1;17791780/*1781 * Above, we put the merged content at the merge-base's1782 * path. Now we usually need to delete both a->path and1783 * b->path. However, the rename on each side of the merge1784 * could also be involved in a rename/add conflict. In1785 * such cases, we should keep the added file around,1786 * resolving the conflict at that path in its favor.1787 */1788 add =filespec_from_entry(&other, ci->dst_entry1,2^1);1789if(add) {1790if(update_file(o,0, &add->oid, add->mode, a->path))1791return-1;1792}1793else1794remove_file_from_index(o->repo->index, a->path);1795 add =filespec_from_entry(&other, ci->dst_entry2,3^1);1796if(add) {1797if(update_file(o,0, &add->oid, add->mode, b->path))1798return-1;1799}1800else1801remove_file_from_index(o->repo->index, b->path);1802}else{1803/*1804 * For each destination path, we need to see if there is a1805 * rename/add collision. If not, we can write the file out1806 * to the specified location.1807 */1808 add =filespec_from_entry(&other, ci->dst_entry1,2^1);1809if(add) {1810if(handle_file_collision(o, a->path,1811 NULL, NULL,1812 ci->branch1, ci->branch2,1813&mfi.oid, mfi.mode,1814&add->oid, add->mode) <0)1815return-1;1816}else{1817char*new_path =find_path_for_conflict(o, a->path,1818 ci->branch1,1819 ci->branch2);1820if(update_file(o,0, &mfi.oid, mfi.mode, new_path ? new_path : a->path))1821return-1;1822free(new_path);1823if(update_stages(o, a->path, NULL, a, NULL))1824return-1;1825}18261827 add =filespec_from_entry(&other, ci->dst_entry2,3^1);1828if(add) {1829if(handle_file_collision(o, b->path,1830 NULL, NULL,1831 ci->branch1, ci->branch2,1832&add->oid, add->mode,1833&mfi.oid, mfi.mode) <0)1834return-1;1835}else{1836char*new_path =find_path_for_conflict(o, b->path,1837 ci->branch2,1838 ci->branch1);1839if(update_file(o,0, &mfi.oid, mfi.mode, new_path ? new_path : b->path))1840return-1;1841free(new_path);1842if(update_stages(o, b->path, NULL, NULL, b))1843return-1;1844}1845}18461847return0;1848}18491850static inthandle_rename_rename_2to1(struct merge_options *o,1851struct rename_conflict_info *ci)1852{1853/* Two files, a & b, were renamed to the same thing, c. */1854struct diff_filespec *a = ci->pair1->one;1855struct diff_filespec *b = ci->pair2->one;1856struct diff_filespec *c1 = ci->pair1->two;1857struct diff_filespec *c2 = ci->pair2->two;1858char*path = c1->path;/* == c2->path */1859char*path_side_1_desc;1860char*path_side_2_desc;1861struct merge_file_info mfi_c1;1862struct merge_file_info mfi_c2;18631864output(o,1,_("CONFLICT (rename/rename): "1865"Rename%s->%sin%s. "1866"Rename%s->%sin%s"),1867 a->path, c1->path, ci->branch1,1868 b->path, c2->path, ci->branch2);18691870 path_side_1_desc =xstrfmt("version of%sfrom%s", path, a->path);1871 path_side_2_desc =xstrfmt("version of%sfrom%s", path, b->path);1872if(merge_mode_and_contents(o, a, c1, &ci->ren1_other, path_side_1_desc,1873 o->branch1, o->branch2,18741+ o->call_depth *2, &mfi_c1) ||1875merge_mode_and_contents(o, b, &ci->ren2_other, c2, path_side_2_desc,1876 o->branch1, o->branch2,18771+ o->call_depth *2, &mfi_c2))1878return-1;1879free(path_side_1_desc);1880free(path_side_2_desc);18811882returnhandle_file_collision(o, path, a->path, b->path,1883 ci->branch1, ci->branch2,1884&mfi_c1.oid, mfi_c1.mode,1885&mfi_c2.oid, mfi_c2.mode);1886}18871888/*1889 * Get the diff_filepairs changed between o_tree and tree.1890 */1891static struct diff_queue_struct *get_diffpairs(struct merge_options *o,1892struct tree *o_tree,1893struct tree *tree)1894{1895struct diff_queue_struct *ret;1896struct diff_options opts;18971898repo_diff_setup(o->repo, &opts);1899 opts.flags.recursive =1;1900 opts.flags.rename_empty =0;1901 opts.detect_rename =merge_detect_rename(o);1902/*1903 * We do not have logic to handle the detection of copies. In1904 * fact, it may not even make sense to add such logic: would we1905 * really want a change to a base file to be propagated through1906 * multiple other files by a merge?1907 */1908if(opts.detect_rename > DIFF_DETECT_RENAME)1909 opts.detect_rename = DIFF_DETECT_RENAME;1910 opts.rename_limit = o->merge_rename_limit >=0? o->merge_rename_limit :1911 o->diff_rename_limit >=0? o->diff_rename_limit :19121000;1913 opts.rename_score = o->rename_score;1914 opts.show_rename_progress = o->show_rename_progress;1915 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1916diff_setup_done(&opts);1917diff_tree_oid(&o_tree->object.oid, &tree->object.oid,"", &opts);1918diffcore_std(&opts);1919if(opts.needed_rename_limit > o->needed_rename_limit)1920 o->needed_rename_limit = opts.needed_rename_limit;19211922 ret =xmalloc(sizeof(*ret));1923*ret = diff_queued_diff;19241925 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1926 diff_queued_diff.nr =0;1927 diff_queued_diff.queue = NULL;1928diff_flush(&opts);1929return ret;1930}19311932static inttree_has_path(struct tree *tree,const char*path)1933{1934struct object_id hashy;1935unsigned int mode_o;19361937return!get_tree_entry(&tree->object.oid, path,1938&hashy, &mode_o);1939}19401941/*1942 * Return a new string that replaces the beginning portion (which matches1943 * entry->dir), with entry->new_dir. In perl-speak:1944 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1945 * NOTE:1946 * Caller must ensure that old_path starts with entry->dir + '/'.1947 */1948static char*apply_dir_rename(struct dir_rename_entry *entry,1949const char*old_path)1950{1951struct strbuf new_path = STRBUF_INIT;1952int oldlen, newlen;19531954if(entry->non_unique_new_dir)1955return NULL;19561957 oldlen =strlen(entry->dir);1958 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) +1;1959strbuf_grow(&new_path, newlen);1960strbuf_addbuf(&new_path, &entry->new_dir);1961strbuf_addstr(&new_path, &old_path[oldlen]);19621963returnstrbuf_detach(&new_path, NULL);1964}19651966static voidget_renamed_dir_portion(const char*old_path,const char*new_path,1967char**old_dir,char**new_dir)1968{1969char*end_of_old, *end_of_new;1970int old_len, new_len;19711972*old_dir = NULL;1973*new_dir = NULL;19741975/*1976 * For1977 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1978 * the "e/foo.c" part is the same, we just want to know that1979 * "a/b/c/d" was renamed to "a/b/some/thing/else"1980 * so, for this example, this function returns "a/b/c/d" in1981 * *old_dir and "a/b/some/thing/else" in *new_dir.1982 *1983 * Also, if the basename of the file changed, we don't care. We1984 * want to know which portion of the directory, if any, changed.1985 */1986 end_of_old =strrchr(old_path,'/');1987 end_of_new =strrchr(new_path,'/');19881989if(end_of_old == NULL || end_of_new == NULL)1990return;1991while(*--end_of_new == *--end_of_old &&1992 end_of_old != old_path &&1993 end_of_new != new_path)1994;/* Do nothing; all in the while loop */1995/*1996 * We've found the first non-matching character in the directory1997 * paths. That means the current directory we were comparing1998 * represents the rename. Move end_of_old and end_of_new back1999 * to the full directory name.2000 */2001if(*end_of_old =='/')2002 end_of_old++;2003if(*end_of_old !='/')2004 end_of_new++;2005 end_of_old =strchr(end_of_old,'/');2006 end_of_new =strchr(end_of_new,'/');20072008/*2009 * It may have been the case that old_path and new_path were the same2010 * directory all along. Don't claim a rename if they're the same.2011 */2012 old_len = end_of_old - old_path;2013 new_len = end_of_new - new_path;20142015if(old_len != new_len ||strncmp(old_path, new_path, old_len)) {2016*old_dir =xstrndup(old_path, old_len);2017*new_dir =xstrndup(new_path, new_len);2018}2019}20202021static voidremove_hashmap_entries(struct hashmap *dir_renames,2022struct string_list *items_to_remove)2023{2024int i;2025struct dir_rename_entry *entry;20262027for(i =0; i < items_to_remove->nr; i++) {2028 entry = items_to_remove->items[i].util;2029hashmap_remove(dir_renames, entry, NULL);2030}2031string_list_clear(items_to_remove,0);2032}20332034/*2035 * See if there is a directory rename for path, and if there are any file2036 * level conflicts for the renamed location. If there is a rename and2037 * there are no conflicts, return the new name. Otherwise, return NULL.2038 */2039static char*handle_path_level_conflicts(struct merge_options *o,2040const char*path,2041struct dir_rename_entry *entry,2042struct hashmap *collisions,2043struct tree *tree)2044{2045char*new_path = NULL;2046struct collision_entry *collision_ent;2047int clean =1;2048struct strbuf collision_paths = STRBUF_INIT;20492050/*2051 * entry has the mapping of old directory name to new directory name2052 * that we want to apply to path.2053 */2054 new_path =apply_dir_rename(entry, path);20552056if(!new_path) {2057/* This should only happen when entry->non_unique_new_dir set */2058if(!entry->non_unique_new_dir)2059BUG("entry->non_unqiue_dir not set and !new_path");2060output(o,1,_("CONFLICT (directory rename split): "2061"Unclear where to place%sbecause directory "2062"%swas renamed to multiple other directories, "2063"with no destination getting a majority of the "2064"files."),2065 path, entry->dir);2066 clean =0;2067return NULL;2068}20692070/*2071 * The caller needs to have ensured that it has pre-populated2072 * collisions with all paths that map to new_path. Do a quick check2073 * to ensure that's the case.2074 */2075 collision_ent =collision_find_entry(collisions, new_path);2076if(collision_ent == NULL)2077BUG("collision_ent is NULL");20782079/*2080 * Check for one-sided add/add/.../add conflicts, i.e.2081 * where implicit renames from the other side doing2082 * directory rename(s) can affect this side of history2083 * to put multiple paths into the same location. Warn2084 * and bail on directory renames for such paths.2085 */2086if(collision_ent->reported_already) {2087 clean =0;2088}else if(tree_has_path(tree, new_path)) {2089 collision_ent->reported_already =1;2090strbuf_add_separated_string_list(&collision_paths,", ",2091&collision_ent->source_files);2092output(o,1,_("CONFLICT (implicit dir rename): Existing "2093"file/dir at%sin the way of implicit "2094"directory rename(s) putting the following "2095"path(s) there:%s."),2096 new_path, collision_paths.buf);2097 clean =0;2098}else if(collision_ent->source_files.nr >1) {2099 collision_ent->reported_already =1;2100strbuf_add_separated_string_list(&collision_paths,", ",2101&collision_ent->source_files);2102output(o,1,_("CONFLICT (implicit dir rename): Cannot map "2103"more than one path to%s; implicit directory "2104"renames tried to put these paths there:%s"),2105 new_path, collision_paths.buf);2106 clean =0;2107}21082109/* Free memory we no longer need */2110strbuf_release(&collision_paths);2111if(!clean && new_path) {2112free(new_path);2113return NULL;2114}21152116return new_path;2117}21182119/*2120 * There are a couple things we want to do at the directory level:2121 * 1. Check for both sides renaming to the same thing, in order to avoid2122 * implicit renaming of files that should be left in place. (See2123 * testcase 6b in t6043 for details.)2124 * 2. Prune directory renames if there are still files left in the2125 * the original directory. These represent a partial directory rename,2126 * i.e. a rename where only some of the files within the directory2127 * were renamed elsewhere. (Technically, this could be done earlier2128 * in get_directory_renames(), except that would prevent us from2129 * doing the previous check and thus failing testcase 6b.)2130 * 3. Check for rename/rename(1to2) conflicts (at the directory level).2131 * In the future, we could potentially record this info as well and2132 * omit reporting rename/rename(1to2) conflicts for each path within2133 * the affected directories, thus cleaning up the merge output.2134 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the2135 * directory level, because merging directories is fine. If it2136 * causes conflicts for files within those merged directories, then2137 * that should be detected at the individual path level.2138 */2139static voidhandle_directory_level_conflicts(struct merge_options *o,2140struct hashmap *dir_re_head,2141struct tree *head,2142struct hashmap *dir_re_merge,2143struct tree *merge)2144{2145struct hashmap_iter iter;2146struct dir_rename_entry *head_ent;2147struct dir_rename_entry *merge_ent;21482149struct string_list remove_from_head = STRING_LIST_INIT_NODUP;2150struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;21512152hashmap_iter_init(dir_re_head, &iter);2153while((head_ent =hashmap_iter_next(&iter))) {2154 merge_ent =dir_rename_find_entry(dir_re_merge, head_ent->dir);2155if(merge_ent &&2156!head_ent->non_unique_new_dir &&2157!merge_ent->non_unique_new_dir &&2158!strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {2159/* 1. Renamed identically; remove it from both sides */2160string_list_append(&remove_from_head,2161 head_ent->dir)->util = head_ent;2162strbuf_release(&head_ent->new_dir);2163string_list_append(&remove_from_merge,2164 merge_ent->dir)->util = merge_ent;2165strbuf_release(&merge_ent->new_dir);2166}else if(tree_has_path(head, head_ent->dir)) {2167/* 2. This wasn't a directory rename after all */2168string_list_append(&remove_from_head,2169 head_ent->dir)->util = head_ent;2170strbuf_release(&head_ent->new_dir);2171}2172}21732174remove_hashmap_entries(dir_re_head, &remove_from_head);2175remove_hashmap_entries(dir_re_merge, &remove_from_merge);21762177hashmap_iter_init(dir_re_merge, &iter);2178while((merge_ent =hashmap_iter_next(&iter))) {2179 head_ent =dir_rename_find_entry(dir_re_head, merge_ent->dir);2180if(tree_has_path(merge, merge_ent->dir)) {2181/* 2. This wasn't a directory rename after all */2182string_list_append(&remove_from_merge,2183 merge_ent->dir)->util = merge_ent;2184}else if(head_ent &&2185!head_ent->non_unique_new_dir &&2186!merge_ent->non_unique_new_dir) {2187/* 3. rename/rename(1to2) */2188/*2189 * We can assume it's not rename/rename(1to1) because2190 * that was case (1), already checked above. So we2191 * know that head_ent->new_dir and merge_ent->new_dir2192 * are different strings.2193 */2194output(o,1,_("CONFLICT (rename/rename): "2195"Rename directory%s->%sin%s. "2196"Rename directory%s->%sin%s"),2197 head_ent->dir, head_ent->new_dir.buf, o->branch1,2198 head_ent->dir, merge_ent->new_dir.buf, o->branch2);2199string_list_append(&remove_from_head,2200 head_ent->dir)->util = head_ent;2201strbuf_release(&head_ent->new_dir);2202string_list_append(&remove_from_merge,2203 merge_ent->dir)->util = merge_ent;2204strbuf_release(&merge_ent->new_dir);2205}2206}22072208remove_hashmap_entries(dir_re_head, &remove_from_head);2209remove_hashmap_entries(dir_re_merge, &remove_from_merge);2210}22112212static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,2213struct tree *tree)2214{2215struct hashmap *dir_renames;2216struct hashmap_iter iter;2217struct dir_rename_entry *entry;2218int i;22192220/*2221 * Typically, we think of a directory rename as all files from a2222 * certain directory being moved to a target directory. However,2223 * what if someone first moved two files from the original2224 * directory in one commit, and then renamed the directory2225 * somewhere else in a later commit? At merge time, we just know2226 * that files from the original directory went to two different2227 * places, and that the bulk of them ended up in the same place.2228 * We want each directory rename to represent where the bulk of the2229 * files from that directory end up; this function exists to find2230 * where the bulk of the files went.2231 *2232 * The first loop below simply iterates through the list of file2233 * renames, finding out how often each directory rename pair2234 * possibility occurs.2235 */2236 dir_renames =xmalloc(sizeof(*dir_renames));2237dir_rename_init(dir_renames);2238for(i =0; i < pairs->nr; ++i) {2239struct string_list_item *item;2240int*count;2241struct diff_filepair *pair = pairs->queue[i];2242char*old_dir, *new_dir;22432244/* File not part of directory rename if it wasn't renamed */2245if(pair->status !='R')2246continue;22472248get_renamed_dir_portion(pair->one->path, pair->two->path,2249&old_dir, &new_dir);2250if(!old_dir)2251/* Directory didn't change at all; ignore this one. */2252continue;22532254 entry =dir_rename_find_entry(dir_renames, old_dir);2255if(!entry) {2256 entry =xmalloc(sizeof(*entry));2257dir_rename_entry_init(entry, old_dir);2258hashmap_put(dir_renames, entry);2259}else{2260free(old_dir);2261}2262 item =string_list_lookup(&entry->possible_new_dirs, new_dir);2263if(!item) {2264 item =string_list_insert(&entry->possible_new_dirs,2265 new_dir);2266 item->util =xcalloc(1,sizeof(int));2267}else{2268free(new_dir);2269}2270 count = item->util;2271*count +=1;2272}22732274/*2275 * For each directory with files moved out of it, we find out which2276 * target directory received the most files so we can declare it to2277 * be the "winning" target location for the directory rename. This2278 * winner gets recorded in new_dir. If there is no winner2279 * (multiple target directories received the same number of files),2280 * we set non_unique_new_dir. Once we've determined the winner (or2281 * that there is no winner), we no longer need possible_new_dirs.2282 */2283hashmap_iter_init(dir_renames, &iter);2284while((entry =hashmap_iter_next(&iter))) {2285int max =0;2286int bad_max =0;2287char*best = NULL;22882289for(i =0; i < entry->possible_new_dirs.nr; i++) {2290int*count = entry->possible_new_dirs.items[i].util;22912292if(*count == max)2293 bad_max = max;2294else if(*count > max) {2295 max = *count;2296 best = entry->possible_new_dirs.items[i].string;2297}2298}2299if(bad_max == max)2300 entry->non_unique_new_dir =1;2301else{2302assert(entry->new_dir.len ==0);2303strbuf_addstr(&entry->new_dir, best);2304}2305/*2306 * The relevant directory sub-portion of the original full2307 * filepaths were xstrndup'ed before inserting into2308 * possible_new_dirs, and instead of manually iterating the2309 * list and free'ing each, just lie and tell2310 * possible_new_dirs that it did the strdup'ing so that it2311 * will free them for us.2312 */2313 entry->possible_new_dirs.strdup_strings =1;2314string_list_clear(&entry->possible_new_dirs,1);2315}23162317return dir_renames;2318}23192320static struct dir_rename_entry *check_dir_renamed(const char*path,2321struct hashmap *dir_renames)2322{2323char*temp =xstrdup(path);2324char*end;2325struct dir_rename_entry *entry = NULL;23262327while((end =strrchr(temp,'/'))) {2328*end ='\0';2329 entry =dir_rename_find_entry(dir_renames, temp);2330if(entry)2331break;2332}2333free(temp);2334return entry;2335}23362337static voidcompute_collisions(struct hashmap *collisions,2338struct hashmap *dir_renames,2339struct diff_queue_struct *pairs)2340{2341int i;23422343/*2344 * Multiple files can be mapped to the same path due to directory2345 * renames done by the other side of history. Since that other2346 * side of history could have merged multiple directories into one,2347 * if our side of history added the same file basename to each of2348 * those directories, then all N of them would get implicitly2349 * renamed by the directory rename detection into the same path,2350 * and we'd get an add/add/.../add conflict, and all those adds2351 * from *this* side of history. This is not representable in the2352 * index, and users aren't going to easily be able to make sense of2353 * it. So we need to provide a good warning about what's2354 * happening, and fall back to no-directory-rename detection2355 * behavior for those paths.2356 *2357 * See testcases 9e and all of section 5 from t6043 for examples.2358 */2359collision_init(collisions);23602361for(i =0; i < pairs->nr; ++i) {2362struct dir_rename_entry *dir_rename_ent;2363struct collision_entry *collision_ent;2364char*new_path;2365struct diff_filepair *pair = pairs->queue[i];23662367if(pair->status !='A'&& pair->status !='R')2368continue;2369 dir_rename_ent =check_dir_renamed(pair->two->path,2370 dir_renames);2371if(!dir_rename_ent)2372continue;23732374 new_path =apply_dir_rename(dir_rename_ent, pair->two->path);2375if(!new_path)2376/*2377 * dir_rename_ent->non_unique_new_path is true, which2378 * means there is no directory rename for us to use,2379 * which means it won't cause us any additional2380 * collisions.2381 */2382continue;2383 collision_ent =collision_find_entry(collisions, new_path);2384if(!collision_ent) {2385 collision_ent =xcalloc(1,2386sizeof(struct collision_entry));2387hashmap_entry_init(collision_ent,strhash(new_path));2388hashmap_put(collisions, collision_ent);2389 collision_ent->target_file = new_path;2390}else{2391free(new_path);2392}2393string_list_insert(&collision_ent->source_files,2394 pair->two->path);2395}2396}23972398static char*check_for_directory_rename(struct merge_options *o,2399const char*path,2400struct tree *tree,2401struct hashmap *dir_renames,2402struct hashmap *dir_rename_exclusions,2403struct hashmap *collisions,2404int*clean_merge)2405{2406char*new_path = NULL;2407struct dir_rename_entry *entry =check_dir_renamed(path, dir_renames);2408struct dir_rename_entry *oentry = NULL;24092410if(!entry)2411return new_path;24122413/*2414 * This next part is a little weird. We do not want to do an2415 * implicit rename into a directory we renamed on our side, because2416 * that will result in a spurious rename/rename(1to2) conflict. An2417 * example:2418 * Base commit: dumbdir/afile, otherdir/bfile2419 * Side 1: smrtdir/afile, otherdir/bfile2420 * Side 2: dumbdir/afile, dumbdir/bfile2421 * Here, while working on Side 1, we could notice that otherdir was2422 * renamed/merged to dumbdir, and change the diff_filepair for2423 * otherdir/bfile into a rename into dumbdir/bfile. However, Side2424 * 2 will notice the rename from dumbdir to smrtdir, and do the2425 * transitive rename to move it from dumbdir/bfile to2426 * smrtdir/bfile. That gives us bfile in dumbdir vs being in2427 * smrtdir, a rename/rename(1to2) conflict. We really just want2428 * the file to end up in smrtdir. And the way to achieve that is2429 * to not let Side1 do the rename to dumbdir, since we know that is2430 * the source of one of our directory renames.2431 *2432 * That's why oentry and dir_rename_exclusions is here.2433 *2434 * As it turns out, this also prevents N-way transient rename2435 * confusion; See testcases 9c and 9d of t6043.2436 */2437 oentry =dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);2438if(oentry) {2439output(o,1,_("WARNING: Avoiding applying%s->%srename "2440"to%s, because%sitself was renamed."),2441 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);2442}else{2443 new_path =handle_path_level_conflicts(o, path, entry,2444 collisions, tree);2445*clean_merge &= (new_path != NULL);2446}24472448return new_path;2449}24502451static voidapply_directory_rename_modifications(struct merge_options *o,2452struct diff_filepair *pair,2453char*new_path,2454struct rename *re,2455struct tree *tree,2456struct tree *o_tree,2457struct tree *a_tree,2458struct tree *b_tree,2459struct string_list *entries,2460int*clean)2461{2462struct string_list_item *item;2463int stage = (tree == a_tree ?2:3);2464int update_wd;24652466/*2467 * In all cases where we can do directory rename detection,2468 * unpack_trees() will have read pair->two->path into the2469 * index and the working copy. We need to remove it so that2470 * we can instead place it at new_path. It is guaranteed to2471 * not be untracked (unpack_trees() would have errored out2472 * saying the file would have been overwritten), but it might2473 * be dirty, though.2474 */2475 update_wd = !was_dirty(o, pair->two->path);2476if(!update_wd)2477output(o,1,_("Refusing to lose dirty file at%s"),2478 pair->two->path);2479remove_file(o,1, pair->two->path, !update_wd);24802481/* Find or create a new re->dst_entry */2482 item =string_list_lookup(entries, new_path);2483if(item) {2484/*2485 * Since we're renaming on this side of history, and it's2486 * due to a directory rename on the other side of history2487 * (which we only allow when the directory in question no2488 * longer exists on the other side of history), the2489 * original entry for re->dst_entry is no longer2490 * necessary...2491 */2492 re->dst_entry->processed =1;24932494/*2495 * ...because we'll be using this new one.2496 */2497 re->dst_entry = item->util;2498}else{2499/*2500 * re->dst_entry is for the before-dir-rename path, and we2501 * need it to hold information for the after-dir-rename2502 * path. Before creating a new entry, we need to mark the2503 * old one as unnecessary (...unless it is shared by2504 * src_entry, i.e. this didn't use to be a rename, in which2505 * case we can just allow the normal processing to happen2506 * for it).2507 */2508if(pair->status =='R')2509 re->dst_entry->processed =1;25102511 re->dst_entry =insert_stage_data(new_path,2512 o_tree, a_tree, b_tree,2513 entries);2514 item =string_list_insert(entries, new_path);2515 item->util = re->dst_entry;2516}25172518/*2519 * Update the stage_data with the information about the path we are2520 * moving into place. That slot will be empty and available for us2521 * to write to because of the collision checks in2522 * handle_path_level_conflicts(). In other words,2523 * re->dst_entry->stages[stage].oid will be the null_oid, so it's2524 * open for us to write to.2525 *2526 * It may be tempting to actually update the index at this point as2527 * well, using update_stages_for_stage_data(), but as per the big2528 * "NOTE" in update_stages(), doing so will modify the current2529 * in-memory index which will break calls to would_lose_untracked()2530 * that we need to make. Instead, we need to just make sure that2531 * the various handle_rename_*() functions update the index2532 * explicitly rather than relying on unpack_trees() to have done it.2533 */2534get_tree_entry(&tree->object.oid,2535 pair->two->path,2536&re->dst_entry->stages[stage].oid,2537&re->dst_entry->stages[stage].mode);25382539/* Update pair status */2540if(pair->status =='A') {2541/*2542 * Recording rename information for this add makes it look2543 * like a rename/delete conflict. Make sure we can2544 * correctly handle this as an add that was moved to a new2545 * directory instead of reporting a rename/delete conflict.2546 */2547 re->add_turned_into_rename =1;2548}2549/*2550 * We don't actually look at pair->status again, but it seems2551 * pedagogically correct to adjust it.2552 */2553 pair->status ='R';25542555/*2556 * Finally, record the new location.2557 */2558 pair->two->path = new_path;2559}25602561/*2562 * Get information of all renames which occurred in 'pairs', making use of2563 * any implicit directory renames inferred from the other side of history.2564 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')2565 * to be able to associate the correct cache entries with the rename2566 * information; tree is always equal to either a_tree or b_tree.2567 */2568static struct string_list *get_renames(struct merge_options *o,2569struct diff_queue_struct *pairs,2570struct hashmap *dir_renames,2571struct hashmap *dir_rename_exclusions,2572struct tree *tree,2573struct tree *o_tree,2574struct tree *a_tree,2575struct tree *b_tree,2576struct string_list *entries,2577int*clean_merge)2578{2579int i;2580struct hashmap collisions;2581struct hashmap_iter iter;2582struct collision_entry *e;2583struct string_list *renames;25842585compute_collisions(&collisions, dir_renames, pairs);2586 renames =xcalloc(1,sizeof(struct string_list));25872588for(i =0; i < pairs->nr; ++i) {2589struct string_list_item *item;2590struct rename *re;2591struct diff_filepair *pair = pairs->queue[i];2592char*new_path;/* non-NULL only with directory renames */25932594if(pair->status !='A'&& pair->status !='R') {2595diff_free_filepair(pair);2596continue;2597}2598 new_path =check_for_directory_rename(o, pair->two->path, tree,2599 dir_renames,2600 dir_rename_exclusions,2601&collisions,2602 clean_merge);2603if(pair->status !='R'&& !new_path) {2604diff_free_filepair(pair);2605continue;2606}26072608 re =xmalloc(sizeof(*re));2609 re->processed =0;2610 re->add_turned_into_rename =0;2611 re->pair = pair;2612 item =string_list_lookup(entries, re->pair->one->path);2613if(!item)2614 re->src_entry =insert_stage_data(re->pair->one->path,2615 o_tree, a_tree, b_tree, entries);2616else2617 re->src_entry = item->util;26182619 item =string_list_lookup(entries, re->pair->two->path);2620if(!item)2621 re->dst_entry =insert_stage_data(re->pair->two->path,2622 o_tree, a_tree, b_tree, entries);2623else2624 re->dst_entry = item->util;2625 item =string_list_insert(renames, pair->one->path);2626 item->util = re;2627if(new_path)2628apply_directory_rename_modifications(o, pair, new_path,2629 re, tree, o_tree,2630 a_tree, b_tree,2631 entries,2632 clean_merge);2633}26342635hashmap_iter_init(&collisions, &iter);2636while((e =hashmap_iter_next(&iter))) {2637free(e->target_file);2638string_list_clear(&e->source_files,0);2639}2640hashmap_free(&collisions,1);2641return renames;2642}26432644static intprocess_renames(struct merge_options *o,2645struct string_list *a_renames,2646struct string_list *b_renames)2647{2648int clean_merge =1, i, j;2649struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2650struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2651const struct rename *sre;26522653for(i =0; i < a_renames->nr; i++) {2654 sre = a_renames->items[i].util;2655string_list_insert(&a_by_dst, sre->pair->two->path)->util2656= (void*)sre;2657}2658for(i =0; i < b_renames->nr; i++) {2659 sre = b_renames->items[i].util;2660string_list_insert(&b_by_dst, sre->pair->two->path)->util2661= (void*)sre;2662}26632664for(i =0, j =0; i < a_renames->nr || j < b_renames->nr;) {2665struct string_list *renames1, *renames2Dst;2666struct rename *ren1 = NULL, *ren2 = NULL;2667const char*branch1, *branch2;2668const char*ren1_src, *ren1_dst;2669struct string_list_item *lookup;26702671if(i >= a_renames->nr) {2672 ren2 = b_renames->items[j++].util;2673}else if(j >= b_renames->nr) {2674 ren1 = a_renames->items[i++].util;2675}else{2676int compare =strcmp(a_renames->items[i].string,2677 b_renames->items[j].string);2678if(compare <=0)2679 ren1 = a_renames->items[i++].util;2680if(compare >=0)2681 ren2 = b_renames->items[j++].util;2682}26832684/* TODO: refactor, so that 1/2 are not needed */2685if(ren1) {2686 renames1 = a_renames;2687 renames2Dst = &b_by_dst;2688 branch1 = o->branch1;2689 branch2 = o->branch2;2690}else{2691 renames1 = b_renames;2692 renames2Dst = &a_by_dst;2693 branch1 = o->branch2;2694 branch2 = o->branch1;2695SWAP(ren2, ren1);2696}26972698if(ren1->processed)2699continue;2700 ren1->processed =1;2701 ren1->dst_entry->processed =1;2702/* BUG: We should only mark src_entry as processed if we2703 * are not dealing with a rename + add-source case.2704 */2705 ren1->src_entry->processed =1;27062707 ren1_src = ren1->pair->one->path;2708 ren1_dst = ren1->pair->two->path;27092710if(ren2) {2711/* One file renamed on both sides */2712const char*ren2_src = ren2->pair->one->path;2713const char*ren2_dst = ren2->pair->two->path;2714enum rename_type rename_type;2715if(strcmp(ren1_src, ren2_src) !=0)2716BUG("ren1_src != ren2_src");2717 ren2->dst_entry->processed =1;2718 ren2->processed =1;2719if(strcmp(ren1_dst, ren2_dst) !=0) {2720 rename_type = RENAME_ONE_FILE_TO_TWO;2721 clean_merge =0;2722}else{2723 rename_type = RENAME_ONE_FILE_TO_ONE;2724/* BUG: We should only remove ren1_src in2725 * the base stage (think of rename +2726 * add-source cases).2727 */2728remove_file(o,1, ren1_src,1);2729update_entry(ren1->dst_entry,2730 ren1->pair->one,2731 ren1->pair->two,2732 ren2->pair->two);2733}2734setup_rename_conflict_info(rename_type,2735 ren1->pair,2736 ren2->pair,2737 branch1,2738 branch2,2739 ren1->dst_entry,2740 ren2->dst_entry,2741 o,2742 NULL,2743 NULL);2744}else if((lookup =string_list_lookup(renames2Dst, ren1_dst))) {2745/* Two different files renamed to the same thing */2746char*ren2_dst;2747 ren2 = lookup->util;2748 ren2_dst = ren2->pair->two->path;2749if(strcmp(ren1_dst, ren2_dst) !=0)2750BUG("ren1_dst != ren2_dst");27512752 clean_merge =0;2753 ren2->processed =1;2754/*2755 * BUG: We should only mark src_entry as processed2756 * if we are not dealing with a rename + add-source2757 * case.2758 */2759 ren2->src_entry->processed =1;27602761setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2762 ren1->pair,2763 ren2->pair,2764 branch1,2765 branch2,2766 ren1->dst_entry,2767 ren2->dst_entry,2768 o,2769 ren1->src_entry,2770 ren2->src_entry);27712772}else{2773/* Renamed in 1, maybe changed in 2 */2774/* we only use sha1 and mode of these */2775struct diff_filespec src_other, dst_other;2776int try_merge;27772778/*2779 * unpack_trees loads entries from common-commit2780 * into stage 1, from head-commit into stage 2, and2781 * from merge-commit into stage 3. We keep track2782 * of which side corresponds to the rename.2783 */2784int renamed_stage = a_renames == renames1 ?2:3;2785int other_stage = a_renames == renames1 ?3:2;27862787/* BUG: We should only remove ren1_src in the base2788 * stage and in other_stage (think of rename +2789 * add-source case).2790 */2791remove_file(o,1, ren1_src,2792 renamed_stage ==2|| !was_tracked(o, ren1_src));27932794oidcpy(&src_other.oid,2795&ren1->src_entry->stages[other_stage].oid);2796 src_other.mode = ren1->src_entry->stages[other_stage].mode;2797oidcpy(&dst_other.oid,2798&ren1->dst_entry->stages[other_stage].oid);2799 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2800 try_merge =0;28012802if(oid_eq(&src_other.oid, &null_oid) &&2803 ren1->add_turned_into_rename) {2804setup_rename_conflict_info(RENAME_VIA_DIR,2805 ren1->pair,2806 NULL,2807 branch1,2808 branch2,2809 ren1->dst_entry,2810 NULL,2811 o,2812 NULL,2813 NULL);2814}else if(oid_eq(&src_other.oid, &null_oid)) {2815setup_rename_conflict_info(RENAME_DELETE,2816 ren1->pair,2817 NULL,2818 branch1,2819 branch2,2820 ren1->dst_entry,2821 NULL,2822 o,2823 NULL,2824 NULL);2825}else if((dst_other.mode == ren1->pair->two->mode) &&2826oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2827/*2828 * Added file on the other side identical to2829 * the file being renamed: clean merge.2830 * Also, there is no need to overwrite the2831 * file already in the working copy, so call2832 * update_file_flags() instead of2833 * update_file().2834 */2835if(update_file_flags(o,2836&ren1->pair->two->oid,2837 ren1->pair->two->mode,2838 ren1_dst,28391,/* update_cache */28400/* update_wd */))2841 clean_merge = -1;2842}else if(!oid_eq(&dst_other.oid, &null_oid)) {2843/*2844 * Probably not a clean merge, but it's2845 * premature to set clean_merge to 0 here,2846 * because if the rename merges cleanly and2847 * the merge exactly matches the newly added2848 * file, then the merge will be clean.2849 */2850setup_rename_conflict_info(RENAME_ADD,2851 ren1->pair,2852 NULL,2853 branch1,2854 branch2,2855 ren1->dst_entry,2856 NULL,2857 o,2858 ren1->src_entry,2859 NULL);2860}else2861 try_merge =1;28622863if(clean_merge <0)2864goto cleanup_and_return;2865if(try_merge) {2866struct diff_filespec *one, *a, *b;2867 src_other.path = (char*)ren1_src;28682869 one = ren1->pair->one;2870if(a_renames == renames1) {2871 a = ren1->pair->two;2872 b = &src_other;2873}else{2874 b = ren1->pair->two;2875 a = &src_other;2876}2877update_entry(ren1->dst_entry, one, a, b);2878setup_rename_conflict_info(RENAME_NORMAL,2879 ren1->pair,2880 NULL,2881 branch1,2882 NULL,2883 ren1->dst_entry,2884 NULL,2885 o,2886 NULL,2887 NULL);2888}2889}2890}2891cleanup_and_return:2892string_list_clear(&a_by_dst,0);2893string_list_clear(&b_by_dst,0);28942895return clean_merge;2896}28972898struct rename_info {2899struct string_list *head_renames;2900struct string_list *merge_renames;2901};29022903static voidinitial_cleanup_rename(struct diff_queue_struct *pairs,2904struct hashmap *dir_renames)2905{2906struct hashmap_iter iter;2907struct dir_rename_entry *e;29082909hashmap_iter_init(dir_renames, &iter);2910while((e =hashmap_iter_next(&iter))) {2911free(e->dir);2912strbuf_release(&e->new_dir);2913/* possible_new_dirs already cleared in get_directory_renames */2914}2915hashmap_free(dir_renames,1);2916free(dir_renames);29172918free(pairs->queue);2919free(pairs);2920}29212922static intdetect_and_process_renames(struct merge_options *o,2923struct tree *common,2924struct tree *head,2925struct tree *merge,2926struct string_list *entries,2927struct rename_info *ri)2928{2929struct diff_queue_struct *head_pairs, *merge_pairs;2930struct hashmap *dir_re_head, *dir_re_merge;2931int clean =1;29322933 ri->head_renames = NULL;2934 ri->merge_renames = NULL;29352936if(!merge_detect_rename(o))2937return1;29382939 head_pairs =get_diffpairs(o, common, head);2940 merge_pairs =get_diffpairs(o, common, merge);29412942if(o->detect_directory_renames) {2943 dir_re_head =get_directory_renames(head_pairs, head);2944 dir_re_merge =get_directory_renames(merge_pairs, merge);29452946handle_directory_level_conflicts(o,2947 dir_re_head, head,2948 dir_re_merge, merge);2949}else{2950 dir_re_head =xmalloc(sizeof(*dir_re_head));2951 dir_re_merge =xmalloc(sizeof(*dir_re_merge));2952dir_rename_init(dir_re_head);2953dir_rename_init(dir_re_merge);2954}29552956 ri->head_renames =get_renames(o, head_pairs,2957 dir_re_merge, dir_re_head, head,2958 common, head, merge, entries,2959&clean);2960if(clean <0)2961goto cleanup;2962 ri->merge_renames =get_renames(o, merge_pairs,2963 dir_re_head, dir_re_merge, merge,2964 common, head, merge, entries,2965&clean);2966if(clean <0)2967goto cleanup;2968 clean &=process_renames(o, ri->head_renames, ri->merge_renames);29692970cleanup:2971/*2972 * Some cleanup is deferred until cleanup_renames() because the2973 * data structures are still needed and referenced in2974 * process_entry(). But there are a few things we can free now.2975 */2976initial_cleanup_rename(head_pairs, dir_re_head);2977initial_cleanup_rename(merge_pairs, dir_re_merge);29782979return clean;2980}29812982static voidfinal_cleanup_rename(struct string_list *rename)2983{2984const struct rename *re;2985int i;29862987if(rename == NULL)2988return;29892990for(i =0; i < rename->nr; i++) {2991 re = rename->items[i].util;2992diff_free_filepair(re->pair);2993}2994string_list_clear(rename,1);2995free(rename);2996}29972998static voidfinal_cleanup_renames(struct rename_info *re_info)2999{3000final_cleanup_rename(re_info->head_renames);3001final_cleanup_rename(re_info->merge_renames);3002}30033004static struct object_id *stage_oid(const struct object_id *oid,unsigned mode)3005{3006return(is_null_oid(oid) || mode ==0) ? NULL: (struct object_id *)oid;3007}30083009static intread_oid_strbuf(struct merge_options *o,3010const struct object_id *oid,3011struct strbuf *dst)3012{3013void*buf;3014enum object_type type;3015unsigned long size;3016 buf =read_object_file(oid, &type, &size);3017if(!buf)3018returnerr(o,_("cannot read object%s"),oid_to_hex(oid));3019if(type != OBJ_BLOB) {3020free(buf);3021returnerr(o,_("object%sis not a blob"),oid_to_hex(oid));3022}3023strbuf_attach(dst, buf, size, size +1);3024return0;3025}30263027static intblob_unchanged(struct merge_options *opt,3028const struct object_id *o_oid,3029unsigned o_mode,3030const struct object_id *a_oid,3031unsigned a_mode,3032int renormalize,const char*path)3033{3034struct strbuf o = STRBUF_INIT;3035struct strbuf a = STRBUF_INIT;3036int ret =0;/* assume changed for safety */30373038if(a_mode != o_mode)3039return0;3040if(oid_eq(o_oid, a_oid))3041return1;3042if(!renormalize)3043return0;30443045assert(o_oid && a_oid);3046if(read_oid_strbuf(opt, o_oid, &o) ||read_oid_strbuf(opt, a_oid, &a))3047goto error_return;3048/*3049 * Note: binary | is used so that both renormalizations are3050 * performed. Comparison can be skipped if both files are3051 * unchanged since their sha1s have already been compared.3052 */3053if(renormalize_buffer(opt->repo->index, path, o.buf, o.len, &o) |3054renormalize_buffer(opt->repo->index, path, a.buf, a.len, &a))3055 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));30563057error_return:3058strbuf_release(&o);3059strbuf_release(&a);3060return ret;3061}30623063static inthandle_modify_delete(struct merge_options *o,3064const char*path,3065struct object_id *o_oid,int o_mode,3066struct object_id *a_oid,int a_mode,3067struct object_id *b_oid,int b_mode)3068{3069const char*modify_branch, *delete_branch;3070struct object_id *changed_oid;3071int changed_mode;30723073if(a_oid) {3074 modify_branch = o->branch1;3075 delete_branch = o->branch2;3076 changed_oid = a_oid;3077 changed_mode = a_mode;3078}else{3079 modify_branch = o->branch2;3080 delete_branch = o->branch1;3081 changed_oid = b_oid;3082 changed_mode = b_mode;3083}30843085returnhandle_change_delete(o,3086 path, NULL,3087 o_oid, o_mode,3088 changed_oid, changed_mode,3089 modify_branch, delete_branch,3090_("modify"),_("modified"));3091}30923093static inthandle_content_merge(struct merge_options *o,3094const char*path,3095int is_dirty,3096struct object_id *o_oid,int o_mode,3097struct object_id *a_oid,int a_mode,3098struct object_id *b_oid,int b_mode,3099struct rename_conflict_info *rename_conflict_info)3100{3101const char*reason =_("content");3102const char*path1 = NULL, *path2 = NULL;3103struct merge_file_info mfi;3104struct diff_filespec one, a, b;3105unsigned df_conflict_remains =0;31063107if(!o_oid) {3108 reason =_("add/add");3109 o_oid = (struct object_id *)&null_oid;3110}3111 one.path = a.path = b.path = (char*)path;3112oidcpy(&one.oid, o_oid);3113 one.mode = o_mode;3114oidcpy(&a.oid, a_oid);3115 a.mode = a_mode;3116oidcpy(&b.oid, b_oid);3117 b.mode = b_mode;31183119if(rename_conflict_info) {3120struct diff_filepair *pair1 = rename_conflict_info->pair1;31213122 path1 = (o->branch1 == rename_conflict_info->branch1) ?3123 pair1->two->path : pair1->one->path;3124/* If rename_conflict_info->pair2 != NULL, we are in3125 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a3126 * normal rename.3127 */3128 path2 = (rename_conflict_info->pair2 ||3129 o->branch2 == rename_conflict_info->branch1) ?3130 pair1->two->path : pair1->one->path;3131 one.path = pair1->one->path;3132 a.path = (char*)path1;3133 b.path = (char*)path2;31343135if(dir_in_way(o->repo->index, path, !o->call_depth,3136S_ISGITLINK(pair1->two->mode)))3137 df_conflict_remains =1;3138}3139if(merge_mode_and_contents(o, &one, &a, &b, path,3140 o->branch1, o->branch2,3141 o->call_depth *2, &mfi))3142return-1;31433144/*3145 * We can skip updating the working tree file iff:3146 * a) The merge is clean3147 * b) The merge matches what was in HEAD (content, mode, pathname)3148 * c) The target path is usable (i.e. not involved in D/F conflict)3149 */3150if(mfi.clean &&3151was_tracked_and_matches(o, path, &mfi.oid, mfi.mode) &&3152!df_conflict_remains) {3153int pos;3154struct cache_entry *ce;31553156output(o,3,_("Skipped%s(merged same as existing)"), path);3157if(add_cacheinfo(o, mfi.mode, &mfi.oid, path,31580, (!o->call_depth && !is_dirty),0))3159return-1;3160/*3161 * However, add_cacheinfo() will delete the old cache entry3162 * and add a new one. We need to copy over any skip_worktree3163 * flag to avoid making the file appear as if it were3164 * deleted by the user.3165 */3166 pos =index_name_pos(&o->orig_index, path,strlen(path));3167 ce = o->orig_index.cache[pos];3168if(ce_skip_worktree(ce)) {3169 pos =index_name_pos(o->repo->index, path,strlen(path));3170 ce = o->repo->index->cache[pos];3171 ce->ce_flags |= CE_SKIP_WORKTREE;3172}3173return mfi.clean;3174}31753176if(!mfi.clean) {3177if(S_ISGITLINK(mfi.mode))3178 reason =_("submodule");3179output(o,1,_("CONFLICT (%s): Merge conflict in%s"),3180 reason, path);3181if(rename_conflict_info && !df_conflict_remains)3182if(update_stages(o, path, &one, &a, &b))3183return-1;3184}31853186if(df_conflict_remains || is_dirty) {3187char*new_path;3188if(o->call_depth) {3189remove_file_from_index(o->repo->index, path);3190}else{3191if(!mfi.clean) {3192if(update_stages(o, path, &one, &a, &b))3193return-1;3194}else{3195int file_from_stage2 =was_tracked(o, path);3196struct diff_filespec merged;3197oidcpy(&merged.oid, &mfi.oid);3198 merged.mode = mfi.mode;31993200if(update_stages(o, path, NULL,3201 file_from_stage2 ? &merged : NULL,3202 file_from_stage2 ? NULL : &merged))3203return-1;3204}32053206}3207 new_path =unique_path(o, path, rename_conflict_info->branch1);3208if(is_dirty) {3209output(o,1,_("Refusing to lose dirty file at%s"),3210 path);3211}3212output(o,1,_("Adding as%sinstead"), new_path);3213if(update_file(o,0, &mfi.oid, mfi.mode, new_path)) {3214free(new_path);3215return-1;3216}3217free(new_path);3218 mfi.clean =0;3219}else if(update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))3220return-1;3221return!is_dirty && mfi.clean;3222}32233224static inthandle_rename_normal(struct merge_options *o,3225const char*path,3226struct object_id *o_oid,unsigned int o_mode,3227struct object_id *a_oid,unsigned int a_mode,3228struct object_id *b_oid,unsigned int b_mode,3229struct rename_conflict_info *ci)3230{3231/* Merge the content and write it out */3232returnhandle_content_merge(o, path,was_dirty(o, path),3233 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,3234 ci);3235}32363237/* Per entry merge function */3238static intprocess_entry(struct merge_options *o,3239const char*path,struct stage_data *entry)3240{3241int clean_merge =1;3242int normalize = o->renormalize;3243unsigned o_mode = entry->stages[1].mode;3244unsigned a_mode = entry->stages[2].mode;3245unsigned b_mode = entry->stages[3].mode;3246struct object_id *o_oid =stage_oid(&entry->stages[1].oid, o_mode);3247struct object_id *a_oid =stage_oid(&entry->stages[2].oid, a_mode);3248struct object_id *b_oid =stage_oid(&entry->stages[3].oid, b_mode);32493250 entry->processed =1;3251if(entry->rename_conflict_info) {3252struct rename_conflict_info *conflict_info = entry->rename_conflict_info;3253switch(conflict_info->rename_type) {3254case RENAME_NORMAL:3255case RENAME_ONE_FILE_TO_ONE:3256 clean_merge =handle_rename_normal(o,3257 path,3258 o_oid, o_mode,3259 a_oid, a_mode,3260 b_oid, b_mode,3261 conflict_info);3262break;3263case RENAME_VIA_DIR:3264 clean_merge =1;3265if(handle_rename_via_dir(o,3266 conflict_info->pair1,3267 conflict_info->branch1,3268 conflict_info->branch2))3269 clean_merge = -1;3270break;3271case RENAME_ADD:3272/*3273 * Probably unclean merge, but if the renamed file3274 * merges cleanly and the result can then be3275 * two-way merged cleanly with the added file, I3276 * guess it's a clean merge?3277 */3278 clean_merge =handle_rename_add(o, conflict_info);3279break;3280case RENAME_DELETE:3281 clean_merge =0;3282if(handle_rename_delete(o,3283 conflict_info->pair1,3284 conflict_info->branch1,3285 conflict_info->branch2))3286 clean_merge = -1;3287break;3288case RENAME_ONE_FILE_TO_TWO:3289 clean_merge =0;3290if(handle_rename_rename_1to2(o, conflict_info))3291 clean_merge = -1;3292break;3293case RENAME_TWO_FILES_TO_ONE:3294/*3295 * Probably unclean merge, but if the two renamed3296 * files merge cleanly and the two resulting files3297 * can then be two-way merged cleanly, I guess it's3298 * a clean merge?3299 */3300 clean_merge =handle_rename_rename_2to1(o,3301 conflict_info);3302break;3303default:3304 entry->processed =0;3305break;3306}3307}else if(o_oid && (!a_oid || !b_oid)) {3308/* Case A: Deleted in one */3309if((!a_oid && !b_oid) ||3310(!b_oid &&blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||3311(!a_oid &&blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {3312/* Deleted in both or deleted in one and3313 * unchanged in the other */3314if(a_oid)3315output(o,2,_("Removing%s"), path);3316/* do not touch working file if it did not exist */3317remove_file(o,1, path, !a_oid);3318}else{3319/* Modify/delete; deleted side may have put a directory in the way */3320 clean_merge =0;3321if(handle_modify_delete(o, path, o_oid, o_mode,3322 a_oid, a_mode, b_oid, b_mode))3323 clean_merge = -1;3324}3325}else if((!o_oid && a_oid && !b_oid) ||3326(!o_oid && !a_oid && b_oid)) {3327/* Case B: Added in one. */3328/* [nothing|directory] -> ([nothing|directory], file) */33293330const char*add_branch;3331const char*other_branch;3332unsigned mode;3333const struct object_id *oid;3334const char*conf;33353336if(a_oid) {3337 add_branch = o->branch1;3338 other_branch = o->branch2;3339 mode = a_mode;3340 oid = a_oid;3341 conf =_("file/directory");3342}else{3343 add_branch = o->branch2;3344 other_branch = o->branch1;3345 mode = b_mode;3346 oid = b_oid;3347 conf =_("directory/file");3348}3349if(dir_in_way(o->repo->index, path,3350!o->call_depth && !S_ISGITLINK(a_mode),33510)) {3352char*new_path =unique_path(o, path, add_branch);3353 clean_merge =0;3354output(o,1,_("CONFLICT (%s): There is a directory with name%sin%s. "3355"Adding%sas%s"),3356 conf, path, other_branch, path, new_path);3357if(update_file(o,0, oid, mode, new_path))3358 clean_merge = -1;3359else if(o->call_depth)3360remove_file_from_index(o->repo->index, path);3361free(new_path);3362}else{3363output(o,2,_("Adding%s"), path);3364/* do not overwrite file if already present */3365if(update_file_flags(o, oid, mode, path,1, !a_oid))3366 clean_merge = -1;3367}3368}else if(a_oid && b_oid) {3369if(!o_oid) {3370/* Case C: Added in both (check for same permissions) */3371output(o,1,3372_("CONFLICT (add/add): Merge conflict in%s"),3373 path);3374 clean_merge =handle_file_collision(o,3375 path, NULL, NULL,3376 o->branch1,3377 o->branch2,3378 a_oid, a_mode,3379 b_oid, b_mode);3380}else{3381/* case D: Modified in both, but differently. */3382int is_dirty =0;/* unpack_trees would have bailed if dirty */3383 clean_merge =handle_content_merge(o, path,3384 is_dirty,3385 o_oid, o_mode,3386 a_oid, a_mode,3387 b_oid, b_mode,3388 NULL);3389}3390}else if(!o_oid && !a_oid && !b_oid) {3391/*3392 * this entry was deleted altogether. a_mode == 0 means3393 * we had that path and want to actively remove it.3394 */3395remove_file(o,1, path, !a_mode);3396}else3397BUG("fatal merge failure, shouldn't happen.");33983399return clean_merge;3400}34013402intmerge_trees(struct merge_options *o,3403struct tree *head,3404struct tree *merge,3405struct tree *common,3406struct tree **result)3407{3408struct index_state *istate = o->repo->index;3409int code, clean;3410struct strbuf sb = STRBUF_INIT;34113412if(!o->call_depth &&index_has_changes(istate, head, &sb)) {3413err(o,_("Your local changes to the following files would be overwritten by merge:\n%s"),3414 sb.buf);3415return-1;3416}34173418if(o->subtree_shift) {3419 merge =shift_tree_object(head, merge, o->subtree_shift);3420 common =shift_tree_object(head, common, o->subtree_shift);3421}34223423if(oid_eq(&common->object.oid, &merge->object.oid)) {3424output(o,0,_("Already up to date!"));3425*result = head;3426return1;3427}34283429 code =unpack_trees_start(o, common, head, merge);34303431if(code !=0) {3432if(show(o,4) || o->call_depth)3433err(o,_("merging of trees%sand%sfailed"),3434oid_to_hex(&head->object.oid),3435oid_to_hex(&merge->object.oid));3436unpack_trees_finish(o);3437return-1;3438}34393440if(unmerged_index(istate)) {3441struct string_list *entries;3442struct rename_info re_info;3443int i;3444/*3445 * Only need the hashmap while processing entries, so3446 * initialize it here and free it when we are done running3447 * through the entries. Keeping it in the merge_options as3448 * opposed to decaring a local hashmap is for convenience3449 * so that we don't have to pass it to around.3450 */3451hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL,512);3452get_files_dirs(o, head);3453get_files_dirs(o, merge);34543455 entries =get_unmerged(o->repo->index);3456 clean =detect_and_process_renames(o, common, head, merge,3457 entries, &re_info);3458record_df_conflict_files(o, entries);3459if(clean <0)3460goto cleanup;3461for(i = entries->nr-1;0<= i; i--) {3462const char*path = entries->items[i].string;3463struct stage_data *e = entries->items[i].util;3464if(!e->processed) {3465int ret =process_entry(o, path, e);3466if(!ret)3467 clean =0;3468else if(ret <0) {3469 clean = ret;3470goto cleanup;3471}3472}3473}3474for(i =0; i < entries->nr; i++) {3475struct stage_data *e = entries->items[i].util;3476if(!e->processed)3477BUG("unprocessed path???%s",3478 entries->items[i].string);3479}34803481 cleanup:3482final_cleanup_renames(&re_info);34833484string_list_clear(entries,1);3485free(entries);34863487hashmap_free(&o->current_file_dir_set,1);34883489if(clean <0) {3490unpack_trees_finish(o);3491return clean;3492}3493}3494else3495 clean =1;34963497unpack_trees_finish(o);34983499if(o->call_depth && !(*result =write_tree_from_memory(o)))3500return-1;35013502return clean;3503}35043505static struct commit_list *reverse_commit_list(struct commit_list *list)3506{3507struct commit_list *next = NULL, *current, *backup;3508for(current = list; current; current = backup) {3509 backup = current->next;3510 current->next = next;3511 next = current;3512}3513return next;3514}35153516/*3517 * Merge the commits h1 and h2, return the resulting virtual3518 * commit object and a flag indicating the cleanness of the merge.3519 */3520intmerge_recursive(struct merge_options *o,3521struct commit *h1,3522struct commit *h2,3523struct commit_list *ca,3524struct commit **result)3525{3526struct commit_list *iter;3527struct commit *merged_common_ancestors;3528struct tree *mrtree;3529int clean;35303531if(show(o,4)) {3532output(o,4,_("Merging:"));3533output_commit_title(o, h1);3534output_commit_title(o, h2);3535}35363537if(!ca) {3538 ca =get_merge_bases(h1, h2);3539 ca =reverse_commit_list(ca);3540}35413542if(show(o,5)) {3543unsigned cnt =commit_list_count(ca);35443545output(o,5,Q_("found%ucommon ancestor:",3546"found%ucommon ancestors:", cnt), cnt);3547for(iter = ca; iter; iter = iter->next)3548output_commit_title(o, iter->item);3549}35503551 merged_common_ancestors =pop_commit(&ca);3552if(merged_common_ancestors == NULL) {3553/* if there is no common ancestor, use an empty tree */3554struct tree *tree;35553556 tree =lookup_tree(the_repository, the_repository->hash_algo->empty_tree);3557 merged_common_ancestors =make_virtual_commit(tree,"ancestor");3558}35593560for(iter = ca; iter; iter = iter->next) {3561const char*saved_b1, *saved_b2;3562 o->call_depth++;3563/*3564 * When the merge fails, the result contains files3565 * with conflict markers. The cleanness flag is3566 * ignored (unless indicating an error), it was never3567 * actually used, as result of merge_trees has always3568 * overwritten it: the committed "conflicts" were3569 * already resolved.3570 */3571discard_index(o->repo->index);3572 saved_b1 = o->branch1;3573 saved_b2 = o->branch2;3574 o->branch1 ="Temporary merge branch 1";3575 o->branch2 ="Temporary merge branch 2";3576if(merge_recursive(o, merged_common_ancestors, iter->item,3577 NULL, &merged_common_ancestors) <0)3578return-1;3579 o->branch1 = saved_b1;3580 o->branch2 = saved_b2;3581 o->call_depth--;35823583if(!merged_common_ancestors)3584returnerr(o,_("merge returned no commit"));3585}35863587discard_index(o->repo->index);3588if(!o->call_depth)3589repo_read_index(o->repo);35903591 o->ancestor ="merged common ancestors";3592 clean =merge_trees(o,get_commit_tree(h1),get_commit_tree(h2),3593get_commit_tree(merged_common_ancestors),3594&mrtree);3595if(clean <0) {3596flush_output(o);3597return clean;3598}35993600if(o->call_depth) {3601*result =make_virtual_commit(mrtree,"merged tree");3602commit_list_insert(h1, &(*result)->parents);3603commit_list_insert(h2, &(*result)->parents->next);3604}3605flush_output(o);3606if(!o->call_depth && o->buffer_output <2)3607strbuf_release(&o->obuf);3608if(show(o,2))3609diff_warn_rename_limit("merge.renamelimit",3610 o->needed_rename_limit,0);3611return clean;3612}36133614static struct commit *get_ref(const struct object_id *oid,const char*name)3615{3616struct object *object;36173618 object =deref_tag(the_repository,parse_object(the_repository, oid),3619 name,3620strlen(name));3621if(!object)3622return NULL;3623if(object->type == OBJ_TREE)3624returnmake_virtual_commit((struct tree*)object, name);3625if(object->type != OBJ_COMMIT)3626return NULL;3627if(parse_commit((struct commit *)object))3628return NULL;3629return(struct commit *)object;3630}36313632intmerge_recursive_generic(struct merge_options *o,3633const struct object_id *head,3634const struct object_id *merge,3635int num_base_list,3636const struct object_id **base_list,3637struct commit **result)3638{3639int clean;3640struct lock_file lock = LOCK_INIT;3641struct commit *head_commit =get_ref(head, o->branch1);3642struct commit *next_commit =get_ref(merge, o->branch2);3643struct commit_list *ca = NULL;36443645if(base_list) {3646int i;3647for(i =0; i < num_base_list; ++i) {3648struct commit *base;3649if(!(base =get_ref(base_list[i],oid_to_hex(base_list[i]))))3650returnerr(o,_("Could not parse object '%s'"),3651oid_to_hex(base_list[i]));3652commit_list_insert(base, &ca);3653}3654}36553656repo_hold_locked_index(o->repo, &lock, LOCK_DIE_ON_ERROR);3657 clean =merge_recursive(o, head_commit, next_commit, ca,3658 result);3659if(clean <0) {3660rollback_lock_file(&lock);3661return clean;3662}36633664if(write_locked_index(o->repo->index, &lock,3665 COMMIT_LOCK | SKIP_IF_UNCHANGED))3666returnerr(o,_("Unable to write index."));36673668return clean ?0:1;3669}36703671static voidmerge_recursive_config(struct merge_options *o)3672{3673char*value = NULL;3674git_config_get_int("merge.verbosity", &o->verbosity);3675git_config_get_int("diff.renamelimit", &o->diff_rename_limit);3676git_config_get_int("merge.renamelimit", &o->merge_rename_limit);3677if(!git_config_get_string("diff.renames", &value)) {3678 o->diff_detect_rename =git_config_rename("diff.renames", value);3679free(value);3680}3681if(!git_config_get_string("merge.renames", &value)) {3682 o->merge_detect_rename =git_config_rename("merge.renames", value);3683free(value);3684}3685git_config(git_xmerge_config, NULL);3686}36873688voidinit_merge_options(struct merge_options *o,3689struct repository *repo)3690{3691const char*merge_verbosity;3692memset(o,0,sizeof(struct merge_options));3693 o->repo = repo;3694 o->verbosity =2;3695 o->buffer_output =1;3696 o->diff_rename_limit = -1;3697 o->merge_rename_limit = -1;3698 o->renormalize =0;3699 o->diff_detect_rename = -1;3700 o->merge_detect_rename = -1;3701 o->detect_directory_renames =1;3702merge_recursive_config(o);3703 merge_verbosity =getenv("GIT_MERGE_VERBOSITY");3704if(merge_verbosity)3705 o->verbosity =strtol(merge_verbosity, NULL,10);3706if(o->verbosity >=5)3707 o->buffer_output =0;3708strbuf_init(&o->obuf,0);3709string_list_init(&o->df_conflict_file_set,1);3710}37113712intparse_merge_opt(struct merge_options *o,const char*s)3713{3714const char*arg;37153716if(!s || !*s)3717return-1;3718if(!strcmp(s,"ours"))3719 o->recursive_variant = MERGE_RECURSIVE_OURS;3720else if(!strcmp(s,"theirs"))3721 o->recursive_variant = MERGE_RECURSIVE_THEIRS;3722else if(!strcmp(s,"subtree"))3723 o->subtree_shift ="";3724else if(skip_prefix(s,"subtree=", &arg))3725 o->subtree_shift = arg;3726else if(!strcmp(s,"patience"))3727 o->xdl_opts =DIFF_WITH_ALG(o, PATIENCE_DIFF);3728else if(!strcmp(s,"histogram"))3729 o->xdl_opts =DIFF_WITH_ALG(o, HISTOGRAM_DIFF);3730else if(skip_prefix(s,"diff-algorithm=", &arg)) {3731long value =parse_algorithm_value(arg);3732if(value <0)3733return-1;3734/* clear out previous settings */3735DIFF_XDL_CLR(o, NEED_MINIMAL);3736 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3737 o->xdl_opts |= value;3738}3739else if(!strcmp(s,"ignore-space-change"))3740DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);3741else if(!strcmp(s,"ignore-all-space"))3742DIFF_XDL_SET(o, IGNORE_WHITESPACE);3743else if(!strcmp(s,"ignore-space-at-eol"))3744DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);3745else if(!strcmp(s,"ignore-cr-at-eol"))3746DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);3747else if(!strcmp(s,"renormalize"))3748 o->renormalize =1;3749else if(!strcmp(s,"no-renormalize"))3750 o->renormalize =0;3751else if(!strcmp(s,"no-renames"))3752 o->merge_detect_rename =0;3753else if(!strcmp(s,"find-renames")) {3754 o->merge_detect_rename =1;3755 o->rename_score =0;3756}3757else if(skip_prefix(s,"find-renames=", &arg) ||3758skip_prefix(s,"rename-threshold=", &arg)) {3759if((o->rename_score =parse_rename_score(&arg)) == -1|| *arg !=0)3760return-1;3761 o->merge_detect_rename =1;3762}3763else3764return-1;3765return0;3766}