1/* 2 * Recursive Merge algorithm stolen from git-merge-recursive.py by 3 * Fredrik Kuivinen. 4 * The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006 5 */ 6#include"cache.h" 7#include"config.h" 8#include"advice.h" 9#include"lockfile.h" 10#include"cache-tree.h" 11#include"commit.h" 12#include"blob.h" 13#include"builtin.h" 14#include"tree-walk.h" 15#include"diff.h" 16#include"diffcore.h" 17#include"tag.h" 18#include"unpack-trees.h" 19#include"string-list.h" 20#include"xdiff-interface.h" 21#include"ll-merge.h" 22#include"attr.h" 23#include"merge-recursive.h" 24#include"dir.h" 25#include"submodule.h" 26 27struct path_hashmap_entry { 28struct hashmap_entry e; 29char path[FLEX_ARRAY]; 30}; 31 32static intpath_hashmap_cmp(const void*cmp_data, 33const void*entry, 34const void*entry_or_key, 35const void*keydata) 36{ 37const struct path_hashmap_entry *a = entry; 38const struct path_hashmap_entry *b = entry_or_key; 39const char*key = keydata; 40 41if(ignore_case) 42returnstrcasecmp(a->path, key ? key : b->path); 43else 44returnstrcmp(a->path, key ? key : b->path); 45} 46 47static unsigned intpath_hash(const char*path) 48{ 49return ignore_case ?strihash(path) :strhash(path); 50} 51 52static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap, 53char*dir) 54{ 55struct dir_rename_entry key; 56 57if(dir == NULL) 58return NULL; 59hashmap_entry_init(&key,strhash(dir)); 60 key.dir = dir; 61returnhashmap_get(hashmap, &key, NULL); 62} 63 64static intdir_rename_cmp(const void*unused_cmp_data, 65const void*entry, 66const void*entry_or_key, 67const void*unused_keydata) 68{ 69const struct dir_rename_entry *e1 = entry; 70const struct dir_rename_entry *e2 = entry_or_key; 71 72returnstrcmp(e1->dir, e2->dir); 73} 74 75static voiddir_rename_init(struct hashmap *map) 76{ 77hashmap_init(map, dir_rename_cmp, NULL,0); 78} 79 80static voiddir_rename_entry_init(struct dir_rename_entry *entry, 81char*directory) 82{ 83hashmap_entry_init(entry,strhash(directory)); 84 entry->dir = directory; 85 entry->non_unique_new_dir =0; 86strbuf_init(&entry->new_dir,0); 87string_list_init(&entry->possible_new_dirs,0); 88} 89 90static struct collision_entry *collision_find_entry(struct hashmap *hashmap, 91char*target_file) 92{ 93struct collision_entry key; 94 95hashmap_entry_init(&key,strhash(target_file)); 96 key.target_file = target_file; 97returnhashmap_get(hashmap, &key, NULL); 98} 99 100static intcollision_cmp(void*unused_cmp_data, 101const struct collision_entry *e1, 102const struct collision_entry *e2, 103const void*unused_keydata) 104{ 105returnstrcmp(e1->target_file, e2->target_file); 106} 107 108static voidcollision_init(struct hashmap *map) 109{ 110hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL,0); 111} 112 113static voidflush_output(struct merge_options *o) 114{ 115if(o->buffer_output <2&& o->obuf.len) { 116fputs(o->obuf.buf, stdout); 117strbuf_reset(&o->obuf); 118} 119} 120 121static interr(struct merge_options *o,const char*err, ...) 122{ 123va_list params; 124 125if(o->buffer_output <2) 126flush_output(o); 127else{ 128strbuf_complete(&o->obuf,'\n'); 129strbuf_addstr(&o->obuf,"error: "); 130} 131va_start(params, err); 132strbuf_vaddf(&o->obuf, err, params); 133va_end(params); 134if(o->buffer_output >1) 135strbuf_addch(&o->obuf,'\n'); 136else{ 137error("%s", o->obuf.buf); 138strbuf_reset(&o->obuf); 139} 140 141return-1; 142} 143 144static struct tree *shift_tree_object(struct tree *one,struct tree *two, 145const char*subtree_shift) 146{ 147struct object_id shifted; 148 149if(!*subtree_shift) { 150shift_tree(&one->object.oid, &two->object.oid, &shifted,0); 151}else{ 152shift_tree_by(&one->object.oid, &two->object.oid, &shifted, 153 subtree_shift); 154} 155if(!oidcmp(&two->object.oid, &shifted)) 156return two; 157returnlookup_tree(&shifted); 158} 159 160static struct commit *make_virtual_commit(struct tree *tree,const char*comment) 161{ 162struct commit *commit =alloc_commit_node(); 163 164set_merge_remote_desc(commit, comment, (struct object *)commit); 165 commit->tree = tree; 166 commit->object.parsed =1; 167return commit; 168} 169 170/* 171 * Since we use get_tree_entry(), which does not put the read object into 172 * the object pool, we cannot rely on a == b. 173 */ 174static intoid_eq(const struct object_id *a,const struct object_id *b) 175{ 176if(!a && !b) 177return2; 178return a && b &&oidcmp(a, b) ==0; 179} 180 181enum rename_type { 182 RENAME_NORMAL =0, 183 RENAME_DELETE, 184 RENAME_ONE_FILE_TO_ONE, 185 RENAME_ONE_FILE_TO_TWO, 186 RENAME_TWO_FILES_TO_ONE 187}; 188 189struct rename_conflict_info { 190enum rename_type rename_type; 191struct diff_filepair *pair1; 192struct diff_filepair *pair2; 193const char*branch1; 194const char*branch2; 195struct stage_data *dst_entry1; 196struct stage_data *dst_entry2; 197struct diff_filespec ren1_other; 198struct diff_filespec ren2_other; 199}; 200 201/* 202 * Since we want to write the index eventually, we cannot reuse the index 203 * for these (temporary) data. 204 */ 205struct stage_data { 206struct{ 207unsigned mode; 208struct object_id oid; 209} stages[4]; 210struct rename_conflict_info *rename_conflict_info; 211unsigned processed:1; 212}; 213 214staticinlinevoidsetup_rename_conflict_info(enum rename_type rename_type, 215struct diff_filepair *pair1, 216struct diff_filepair *pair2, 217const char*branch1, 218const char*branch2, 219struct stage_data *dst_entry1, 220struct stage_data *dst_entry2, 221struct merge_options *o, 222struct stage_data *src_entry1, 223struct stage_data *src_entry2) 224{ 225struct rename_conflict_info *ci =xcalloc(1,sizeof(struct rename_conflict_info)); 226 ci->rename_type = rename_type; 227 ci->pair1 = pair1; 228 ci->branch1 = branch1; 229 ci->branch2 = branch2; 230 231 ci->dst_entry1 = dst_entry1; 232 dst_entry1->rename_conflict_info = ci; 233 dst_entry1->processed =0; 234 235assert(!pair2 == !dst_entry2); 236if(dst_entry2) { 237 ci->dst_entry2 = dst_entry2; 238 ci->pair2 = pair2; 239 dst_entry2->rename_conflict_info = ci; 240} 241 242if(rename_type == RENAME_TWO_FILES_TO_ONE) { 243/* 244 * For each rename, there could have been 245 * modifications on the side of history where that 246 * file was not renamed. 247 */ 248int ostage1 = o->branch1 == branch1 ?3:2; 249int ostage2 = ostage1 ^1; 250 251 ci->ren1_other.path = pair1->one->path; 252oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid); 253 ci->ren1_other.mode = src_entry1->stages[ostage1].mode; 254 255 ci->ren2_other.path = pair2->one->path; 256oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid); 257 ci->ren2_other.mode = src_entry2->stages[ostage2].mode; 258} 259} 260 261static intshow(struct merge_options *o,int v) 262{ 263return(!o->call_depth && o->verbosity >= v) || o->verbosity >=5; 264} 265 266__attribute__((format(printf,3,4))) 267static voidoutput(struct merge_options *o,int v,const char*fmt, ...) 268{ 269va_list ap; 270 271if(!show(o, v)) 272return; 273 274strbuf_addchars(&o->obuf,' ', o->call_depth *2); 275 276va_start(ap, fmt); 277strbuf_vaddf(&o->obuf, fmt, ap); 278va_end(ap); 279 280strbuf_addch(&o->obuf,'\n'); 281if(!o->buffer_output) 282flush_output(o); 283} 284 285static voidoutput_commit_title(struct merge_options *o,struct commit *commit) 286{ 287strbuf_addchars(&o->obuf,' ', o->call_depth *2); 288if(commit->util) 289strbuf_addf(&o->obuf,"virtual%s\n", 290merge_remote_util(commit)->name); 291else{ 292strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid, 293 DEFAULT_ABBREV); 294strbuf_addch(&o->obuf,' '); 295if(parse_commit(commit) !=0) 296strbuf_addstr(&o->obuf,_("(bad commit)\n")); 297else{ 298const char*title; 299const char*msg =get_commit_buffer(commit, NULL); 300int len =find_commit_subject(msg, &title); 301if(len) 302strbuf_addf(&o->obuf,"%.*s\n", len, title); 303unuse_commit_buffer(commit, msg); 304} 305} 306flush_output(o); 307} 308 309static intadd_cacheinfo(struct merge_options *o, 310unsigned int mode,const struct object_id *oid, 311const char*path,int stage,int refresh,int options) 312{ 313struct cache_entry *ce; 314int ret; 315 316 ce =make_cache_entry(mode, oid ? oid->hash : null_sha1, path, stage,0); 317if(!ce) 318returnerr(o,_("addinfo_cache failed for path '%s'"), path); 319 320 ret =add_cache_entry(ce, options); 321if(refresh) { 322struct cache_entry *nce; 323 324 nce =refresh_cache_entry(ce, CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING); 325if(!nce) 326returnerr(o,_("addinfo_cache failed for path '%s'"), path); 327if(nce != ce) 328 ret =add_cache_entry(nce, options); 329} 330return ret; 331} 332 333static voidinit_tree_desc_from_tree(struct tree_desc *desc,struct tree *tree) 334{ 335parse_tree(tree); 336init_tree_desc(desc, tree->buffer, tree->size); 337} 338 339static intgit_merge_trees(int index_only, 340struct tree *common, 341struct tree *head, 342struct tree *merge) 343{ 344int rc; 345struct tree_desc t[3]; 346struct unpack_trees_options opts; 347 348memset(&opts,0,sizeof(opts)); 349if(index_only) 350 opts.index_only =1; 351else 352 opts.update =1; 353 opts.merge =1; 354 opts.head_idx =2; 355 opts.fn = threeway_merge; 356 opts.src_index = &the_index; 357 opts.dst_index = &the_index; 358setup_unpack_trees_porcelain(&opts,"merge"); 359 360init_tree_desc_from_tree(t+0, common); 361init_tree_desc_from_tree(t+1, head); 362init_tree_desc_from_tree(t+2, merge); 363 364 rc =unpack_trees(3, t, &opts); 365cache_tree_free(&active_cache_tree); 366return rc; 367} 368 369struct tree *write_tree_from_memory(struct merge_options *o) 370{ 371struct tree *result = NULL; 372 373if(unmerged_cache()) { 374int i; 375fprintf(stderr,"BUG: There are unmerged index entries:\n"); 376for(i =0; i < active_nr; i++) { 377const struct cache_entry *ce = active_cache[i]; 378if(ce_stage(ce)) 379fprintf(stderr,"BUG:%d%.*s\n",ce_stage(ce), 380(int)ce_namelen(ce), ce->name); 381} 382die("BUG: unmerged index entries in merge-recursive.c"); 383} 384 385if(!active_cache_tree) 386 active_cache_tree =cache_tree(); 387 388if(!cache_tree_fully_valid(active_cache_tree) && 389cache_tree_update(&the_index,0) <0) { 390err(o,_("error building trees")); 391return NULL; 392} 393 394 result =lookup_tree(&active_cache_tree->oid); 395 396return result; 397} 398 399static intsave_files_dirs(const struct object_id *oid, 400struct strbuf *base,const char*path, 401unsigned int mode,int stage,void*context) 402{ 403struct path_hashmap_entry *entry; 404int baselen = base->len; 405struct merge_options *o = context; 406 407strbuf_addstr(base, path); 408 409FLEX_ALLOC_MEM(entry, path, base->buf, base->len); 410hashmap_entry_init(entry,path_hash(entry->path)); 411hashmap_add(&o->current_file_dir_set, entry); 412 413strbuf_setlen(base, baselen); 414return(S_ISDIR(mode) ? READ_TREE_RECURSIVE :0); 415} 416 417static voidget_files_dirs(struct merge_options *o,struct tree *tree) 418{ 419struct pathspec match_all; 420memset(&match_all,0,sizeof(match_all)); 421read_tree_recursive(tree,"",0,0, &match_all, save_files_dirs, o); 422} 423 424/* 425 * Returns an index_entry instance which doesn't have to correspond to 426 * a real cache entry in Git's index. 427 */ 428static struct stage_data *insert_stage_data(const char*path, 429struct tree *o,struct tree *a,struct tree *b, 430struct string_list *entries) 431{ 432struct string_list_item *item; 433struct stage_data *e =xcalloc(1,sizeof(struct stage_data)); 434get_tree_entry(&o->object.oid, path, 435&e->stages[1].oid, &e->stages[1].mode); 436get_tree_entry(&a->object.oid, path, 437&e->stages[2].oid, &e->stages[2].mode); 438get_tree_entry(&b->object.oid, path, 439&e->stages[3].oid, &e->stages[3].mode); 440 item =string_list_insert(entries, path); 441 item->util = e; 442return e; 443} 444 445/* 446 * Create a dictionary mapping file names to stage_data objects. The 447 * dictionary contains one entry for every path with a non-zero stage entry. 448 */ 449static struct string_list *get_unmerged(void) 450{ 451struct string_list *unmerged =xcalloc(1,sizeof(struct string_list)); 452int i; 453 454 unmerged->strdup_strings =1; 455 456for(i =0; i < active_nr; i++) { 457struct string_list_item *item; 458struct stage_data *e; 459const struct cache_entry *ce = active_cache[i]; 460if(!ce_stage(ce)) 461continue; 462 463 item =string_list_lookup(unmerged, ce->name); 464if(!item) { 465 item =string_list_insert(unmerged, ce->name); 466 item->util =xcalloc(1,sizeof(struct stage_data)); 467} 468 e = item->util; 469 e->stages[ce_stage(ce)].mode = ce->ce_mode; 470oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid); 471} 472 473return unmerged; 474} 475 476static intstring_list_df_name_compare(const char*one,const char*two) 477{ 478int onelen =strlen(one); 479int twolen =strlen(two); 480/* 481 * Here we only care that entries for D/F conflicts are 482 * adjacent, in particular with the file of the D/F conflict 483 * appearing before files below the corresponding directory. 484 * The order of the rest of the list is irrelevant for us. 485 * 486 * To achieve this, we sort with df_name_compare and provide 487 * the mode S_IFDIR so that D/F conflicts will sort correctly. 488 * We use the mode S_IFDIR for everything else for simplicity, 489 * since in other cases any changes in their order due to 490 * sorting cause no problems for us. 491 */ 492int cmp =df_name_compare(one, onelen, S_IFDIR, 493 two, twolen, S_IFDIR); 494/* 495 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure 496 * that 'foo' comes before 'foo/bar'. 497 */ 498if(cmp) 499return cmp; 500return onelen - twolen; 501} 502 503static voidrecord_df_conflict_files(struct merge_options *o, 504struct string_list *entries) 505{ 506/* If there is a D/F conflict and the file for such a conflict 507 * currently exist in the working tree, we want to allow it to be 508 * removed to make room for the corresponding directory if needed. 509 * The files underneath the directories of such D/F conflicts will 510 * be processed before the corresponding file involved in the D/F 511 * conflict. If the D/F directory ends up being removed by the 512 * merge, then we won't have to touch the D/F file. If the D/F 513 * directory needs to be written to the working copy, then the D/F 514 * file will simply be removed (in make_room_for_path()) to make 515 * room for the necessary paths. Note that if both the directory 516 * and the file need to be present, then the D/F file will be 517 * reinstated with a new unique name at the time it is processed. 518 */ 519struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP; 520const char*last_file = NULL; 521int last_len =0; 522int i; 523 524/* 525 * If we're merging merge-bases, we don't want to bother with 526 * any working directory changes. 527 */ 528if(o->call_depth) 529return; 530 531/* Ensure D/F conflicts are adjacent in the entries list. */ 532for(i =0; i < entries->nr; i++) { 533struct string_list_item *next = &entries->items[i]; 534string_list_append(&df_sorted_entries, next->string)->util = 535 next->util; 536} 537 df_sorted_entries.cmp = string_list_df_name_compare; 538string_list_sort(&df_sorted_entries); 539 540string_list_clear(&o->df_conflict_file_set,1); 541for(i =0; i < df_sorted_entries.nr; i++) { 542const char*path = df_sorted_entries.items[i].string; 543int len =strlen(path); 544struct stage_data *e = df_sorted_entries.items[i].util; 545 546/* 547 * Check if last_file & path correspond to a D/F conflict; 548 * i.e. whether path is last_file+'/'+<something>. 549 * If so, record that it's okay to remove last_file to make 550 * room for path and friends if needed. 551 */ 552if(last_file && 553 len > last_len && 554memcmp(path, last_file, last_len) ==0&& 555 path[last_len] =='/') { 556string_list_insert(&o->df_conflict_file_set, last_file); 557} 558 559/* 560 * Determine whether path could exist as a file in the 561 * working directory as a possible D/F conflict. This 562 * will only occur when it exists in stage 2 as a 563 * file. 564 */ 565if(S_ISREG(e->stages[2].mode) ||S_ISLNK(e->stages[2].mode)) { 566 last_file = path; 567 last_len = len; 568}else{ 569 last_file = NULL; 570} 571} 572string_list_clear(&df_sorted_entries,0); 573} 574 575struct rename { 576struct diff_filepair *pair; 577/* 578 * Purpose of src_entry and dst_entry: 579 * 580 * If 'before' is renamed to 'after' then src_entry will contain 581 * the versions of 'before' from the merge_base, HEAD, and MERGE in 582 * stages 1, 2, and 3; dst_entry will contain the respective 583 * versions of 'after' in corresponding locations. Thus, we have a 584 * total of six modes and oids, though some will be null. (Stage 0 585 * is ignored; we're interested in handling conflicts.) 586 * 587 * Since we don't turn on break-rewrites by default, neither 588 * src_entry nor dst_entry can have all three of their stages have 589 * non-null oids, meaning at most four of the six will be non-null. 590 * Also, since this is a rename, both src_entry and dst_entry will 591 * have at least one non-null oid, meaning at least two will be 592 * non-null. Of the six oids, a typical rename will have three be 593 * non-null. Only two implies a rename/delete, and four implies a 594 * rename/add. 595 */ 596struct stage_data *src_entry; 597struct stage_data *dst_entry; 598unsigned processed:1; 599}; 600 601static intupdate_stages(struct merge_options *opt,const char*path, 602const struct diff_filespec *o, 603const struct diff_filespec *a, 604const struct diff_filespec *b) 605{ 606 607/* 608 * NOTE: It is usually a bad idea to call update_stages on a path 609 * before calling update_file on that same path, since it can 610 * sometimes lead to spurious "refusing to lose untracked file..." 611 * messages from update_file (via make_room_for path via 612 * would_lose_untracked). Instead, reverse the order of the calls 613 * (executing update_file first and then update_stages). 614 */ 615int clear =1; 616int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; 617if(clear) 618if(remove_file_from_cache(path)) 619return-1; 620if(o) 621if(add_cacheinfo(opt, o->mode, &o->oid, path,1,0, options)) 622return-1; 623if(a) 624if(add_cacheinfo(opt, a->mode, &a->oid, path,2,0, options)) 625return-1; 626if(b) 627if(add_cacheinfo(opt, b->mode, &b->oid, path,3,0, options)) 628return-1; 629return0; 630} 631 632static voidupdate_entry(struct stage_data *entry, 633struct diff_filespec *o, 634struct diff_filespec *a, 635struct diff_filespec *b) 636{ 637 entry->processed =0; 638 entry->stages[1].mode = o->mode; 639 entry->stages[2].mode = a->mode; 640 entry->stages[3].mode = b->mode; 641oidcpy(&entry->stages[1].oid, &o->oid); 642oidcpy(&entry->stages[2].oid, &a->oid); 643oidcpy(&entry->stages[3].oid, &b->oid); 644} 645 646static intremove_file(struct merge_options *o,int clean, 647const char*path,int no_wd) 648{ 649int update_cache = o->call_depth || clean; 650int update_working_directory = !o->call_depth && !no_wd; 651 652if(update_cache) { 653if(remove_file_from_cache(path)) 654return-1; 655} 656if(update_working_directory) { 657if(ignore_case) { 658struct cache_entry *ce; 659 ce =cache_file_exists(path,strlen(path), ignore_case); 660if(ce &&ce_stage(ce) ==0&&strcmp(path, ce->name)) 661return0; 662} 663if(remove_path(path)) 664return-1; 665} 666return0; 667} 668 669/* add a string to a strbuf, but converting "/" to "_" */ 670static voidadd_flattened_path(struct strbuf *out,const char*s) 671{ 672size_t i = out->len; 673strbuf_addstr(out, s); 674for(; i < out->len; i++) 675if(out->buf[i] =='/') 676 out->buf[i] ='_'; 677} 678 679static char*unique_path(struct merge_options *o,const char*path,const char*branch) 680{ 681struct path_hashmap_entry *entry; 682struct strbuf newpath = STRBUF_INIT; 683int suffix =0; 684size_t base_len; 685 686strbuf_addf(&newpath,"%s~", path); 687add_flattened_path(&newpath, branch); 688 689 base_len = newpath.len; 690while(hashmap_get_from_hash(&o->current_file_dir_set, 691path_hash(newpath.buf), newpath.buf) || 692(!o->call_depth &&file_exists(newpath.buf))) { 693strbuf_setlen(&newpath, base_len); 694strbuf_addf(&newpath,"_%d", suffix++); 695} 696 697FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len); 698hashmap_entry_init(entry,path_hash(entry->path)); 699hashmap_add(&o->current_file_dir_set, entry); 700returnstrbuf_detach(&newpath, NULL); 701} 702 703/** 704 * Check whether a directory in the index is in the way of an incoming 705 * file. Return 1 if so. If check_working_copy is non-zero, also 706 * check the working directory. If empty_ok is non-zero, also return 707 * 0 in the case where the working-tree dir exists but is empty. 708 */ 709static intdir_in_way(const char*path,int check_working_copy,int empty_ok) 710{ 711int pos; 712struct strbuf dirpath = STRBUF_INIT; 713struct stat st; 714 715strbuf_addstr(&dirpath, path); 716strbuf_addch(&dirpath,'/'); 717 718 pos =cache_name_pos(dirpath.buf, dirpath.len); 719 720if(pos <0) 721 pos = -1- pos; 722if(pos < active_nr && 723!strncmp(dirpath.buf, active_cache[pos]->name, dirpath.len)) { 724strbuf_release(&dirpath); 725return1; 726} 727 728strbuf_release(&dirpath); 729return check_working_copy && !lstat(path, &st) &&S_ISDIR(st.st_mode) && 730!(empty_ok &&is_empty_dir(path)); 731} 732 733static intwas_tracked(const char*path) 734{ 735int pos =cache_name_pos(path,strlen(path)); 736 737if(0<= pos) 738/* we have been tracking this path */ 739return1; 740 741/* 742 * Look for an unmerged entry for the path, 743 * specifically stage #2, which would indicate 744 * that "our" side before the merge started 745 * had the path tracked (and resulted in a conflict). 746 */ 747for(pos = -1- pos; 748 pos < active_nr && !strcmp(path, active_cache[pos]->name); 749 pos++) 750if(ce_stage(active_cache[pos]) ==2) 751return1; 752return0; 753} 754 755static intwould_lose_untracked(const char*path) 756{ 757return!was_tracked(path) &&file_exists(path); 758} 759 760static intmake_room_for_path(struct merge_options *o,const char*path) 761{ 762int status, i; 763const char*msg =_("failed to create path '%s'%s"); 764 765/* Unlink any D/F conflict files that are in the way */ 766for(i =0; i < o->df_conflict_file_set.nr; i++) { 767const char*df_path = o->df_conflict_file_set.items[i].string; 768size_t pathlen =strlen(path); 769size_t df_pathlen =strlen(df_path); 770if(df_pathlen < pathlen && 771 path[df_pathlen] =='/'&& 772strncmp(path, df_path, df_pathlen) ==0) { 773output(o,3, 774_("Removing%sto make room for subdirectory\n"), 775 df_path); 776unlink(df_path); 777unsorted_string_list_delete_item(&o->df_conflict_file_set, 778 i,0); 779break; 780} 781} 782 783/* Make sure leading directories are created */ 784 status =safe_create_leading_directories_const(path); 785if(status) { 786if(status == SCLD_EXISTS) 787/* something else exists */ 788returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 789returnerr(o, msg, path,""); 790} 791 792/* 793 * Do not unlink a file in the work tree if we are not 794 * tracking it. 795 */ 796if(would_lose_untracked(path)) 797returnerr(o,_("refusing to lose untracked file at '%s'"), 798 path); 799 800/* Successful unlink is good.. */ 801if(!unlink(path)) 802return0; 803/* .. and so is no existing file */ 804if(errno == ENOENT) 805return0; 806/* .. but not some other error (who really cares what?) */ 807returnerr(o, msg, path,_(": perhaps a D/F conflict?")); 808} 809 810static intupdate_file_flags(struct merge_options *o, 811const struct object_id *oid, 812unsigned mode, 813const char*path, 814int update_cache, 815int update_wd) 816{ 817int ret =0; 818 819if(o->call_depth) 820 update_wd =0; 821 822if(update_wd) { 823enum object_type type; 824void*buf; 825unsigned long size; 826 827if(S_ISGITLINK(mode)) { 828/* 829 * We may later decide to recursively descend into 830 * the submodule directory and update its index 831 * and/or work tree, but we do not do that now. 832 */ 833 update_wd =0; 834goto update_index; 835} 836 837 buf =read_object_file(oid, &type, &size); 838if(!buf) 839returnerr(o,_("cannot read object%s'%s'"),oid_to_hex(oid), path); 840if(type != OBJ_BLOB) { 841 ret =err(o,_("blob expected for%s'%s'"),oid_to_hex(oid), path); 842goto free_buf; 843} 844if(S_ISREG(mode)) { 845struct strbuf strbuf = STRBUF_INIT; 846if(convert_to_working_tree(path, buf, size, &strbuf)) { 847free(buf); 848 size = strbuf.len; 849 buf =strbuf_detach(&strbuf, NULL); 850} 851} 852 853if(make_room_for_path(o, path) <0) { 854 update_wd =0; 855goto free_buf; 856} 857if(S_ISREG(mode) || (!has_symlinks &&S_ISLNK(mode))) { 858int fd; 859if(mode &0100) 860 mode =0777; 861else 862 mode =0666; 863 fd =open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 864if(fd <0) { 865 ret =err(o,_("failed to open '%s':%s"), 866 path,strerror(errno)); 867goto free_buf; 868} 869write_in_full(fd, buf, size); 870close(fd); 871}else if(S_ISLNK(mode)) { 872char*lnk =xmemdupz(buf, size); 873safe_create_leading_directories_const(path); 874unlink(path); 875if(symlink(lnk, path)) 876 ret =err(o,_("failed to symlink '%s':%s"), 877 path,strerror(errno)); 878free(lnk); 879}else 880 ret =err(o, 881_("do not know what to do with%06o%s'%s'"), 882 mode,oid_to_hex(oid), path); 883 free_buf: 884free(buf); 885} 886 update_index: 887if(!ret && update_cache) 888add_cacheinfo(o, mode, oid, path,0, update_wd, ADD_CACHE_OK_TO_ADD); 889return ret; 890} 891 892static intupdate_file(struct merge_options *o, 893int clean, 894const struct object_id *oid, 895unsigned mode, 896const char*path) 897{ 898returnupdate_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth); 899} 900 901/* Low level file merging, update and removal */ 902 903struct merge_file_info { 904struct object_id oid; 905unsigned mode; 906unsigned clean:1, 907 merge:1; 908}; 909 910static intmerge_3way(struct merge_options *o, 911 mmbuffer_t *result_buf, 912const struct diff_filespec *one, 913const struct diff_filespec *a, 914const struct diff_filespec *b, 915const char*branch1, 916const char*branch2) 917{ 918 mmfile_t orig, src1, src2; 919struct ll_merge_options ll_opts = {0}; 920char*base_name, *name1, *name2; 921int merge_status; 922 923 ll_opts.renormalize = o->renormalize; 924 ll_opts.xdl_opts = o->xdl_opts; 925 926if(o->call_depth) { 927 ll_opts.virtual_ancestor =1; 928 ll_opts.variant =0; 929}else{ 930switch(o->recursive_variant) { 931case MERGE_RECURSIVE_OURS: 932 ll_opts.variant = XDL_MERGE_FAVOR_OURS; 933break; 934case MERGE_RECURSIVE_THEIRS: 935 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS; 936break; 937default: 938 ll_opts.variant =0; 939break; 940} 941} 942 943if(strcmp(a->path, b->path) || 944(o->ancestor != NULL &&strcmp(a->path, one->path) !=0)) { 945 base_name = o->ancestor == NULL ? NULL : 946mkpathdup("%s:%s", o->ancestor, one->path); 947 name1 =mkpathdup("%s:%s", branch1, a->path); 948 name2 =mkpathdup("%s:%s", branch2, b->path); 949}else{ 950 base_name = o->ancestor == NULL ? NULL : 951mkpathdup("%s", o->ancestor); 952 name1 =mkpathdup("%s", branch1); 953 name2 =mkpathdup("%s", branch2); 954} 955 956read_mmblob(&orig, &one->oid); 957read_mmblob(&src1, &a->oid); 958read_mmblob(&src2, &b->oid); 959 960 merge_status =ll_merge(result_buf, a->path, &orig, base_name, 961&src1, name1, &src2, name2, &ll_opts); 962 963free(base_name); 964free(name1); 965free(name2); 966free(orig.ptr); 967free(src1.ptr); 968free(src2.ptr); 969return merge_status; 970} 971 972static intmerge_file_1(struct merge_options *o, 973const struct diff_filespec *one, 974const struct diff_filespec *a, 975const struct diff_filespec *b, 976const char*branch1, 977const char*branch2, 978struct merge_file_info *result) 979{ 980 result->merge =0; 981 result->clean =1; 982 983if((S_IFMT & a->mode) != (S_IFMT & b->mode)) { 984 result->clean =0; 985if(S_ISREG(a->mode)) { 986 result->mode = a->mode; 987oidcpy(&result->oid, &a->oid); 988}else{ 989 result->mode = b->mode; 990oidcpy(&result->oid, &b->oid); 991} 992}else{ 993if(!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid)) 994 result->merge =1; 995 996/* 997 * Merge modes 998 */ 999if(a->mode == b->mode || a->mode == one->mode)1000 result->mode = b->mode;1001else{1002 result->mode = a->mode;1003if(b->mode != one->mode) {1004 result->clean =0;1005 result->merge =1;1006}1007}10081009if(oid_eq(&a->oid, &b->oid) ||oid_eq(&a->oid, &one->oid))1010oidcpy(&result->oid, &b->oid);1011else if(oid_eq(&b->oid, &one->oid))1012oidcpy(&result->oid, &a->oid);1013else if(S_ISREG(a->mode)) {1014 mmbuffer_t result_buf;1015int ret =0, merge_status;10161017 merge_status =merge_3way(o, &result_buf, one, a, b,1018 branch1, branch2);10191020if((merge_status <0) || !result_buf.ptr)1021 ret =err(o,_("Failed to execute internal merge"));10221023if(!ret &&1024write_object_file(result_buf.ptr, result_buf.size,1025 blob_type, &result->oid))1026 ret =err(o,_("Unable to add%sto database"),1027 a->path);10281029free(result_buf.ptr);1030if(ret)1031return ret;1032 result->clean = (merge_status ==0);1033}else if(S_ISGITLINK(a->mode)) {1034 result->clean =merge_submodule(&result->oid,1035 one->path,1036&one->oid,1037&a->oid,1038&b->oid,1039!o->call_depth);1040}else if(S_ISLNK(a->mode)) {1041switch(o->recursive_variant) {1042case MERGE_RECURSIVE_NORMAL:1043oidcpy(&result->oid, &a->oid);1044if(!oid_eq(&a->oid, &b->oid))1045 result->clean =0;1046break;1047case MERGE_RECURSIVE_OURS:1048oidcpy(&result->oid, &a->oid);1049break;1050case MERGE_RECURSIVE_THEIRS:1051oidcpy(&result->oid, &b->oid);1052break;1053}1054}else1055die("BUG: unsupported object type in the tree");1056}10571058return0;1059}10601061static intmerge_file_special_markers(struct merge_options *o,1062const struct diff_filespec *one,1063const struct diff_filespec *a,1064const struct diff_filespec *b,1065const char*branch1,1066const char*filename1,1067const char*branch2,1068const char*filename2,1069struct merge_file_info *mfi)1070{1071char*side1 = NULL;1072char*side2 = NULL;1073int ret;10741075if(filename1)1076 side1 =xstrfmt("%s:%s", branch1, filename1);1077if(filename2)1078 side2 =xstrfmt("%s:%s", branch2, filename2);10791080 ret =merge_file_1(o, one, a, b,1081 side1 ? side1 : branch1,1082 side2 ? side2 : branch2, mfi);1083free(side1);1084free(side2);1085return ret;1086}10871088static intmerge_file_one(struct merge_options *o,1089const char*path,1090const struct object_id *o_oid,int o_mode,1091const struct object_id *a_oid,int a_mode,1092const struct object_id *b_oid,int b_mode,1093const char*branch1,1094const char*branch2,1095struct merge_file_info *mfi)1096{1097struct diff_filespec one, a, b;10981099 one.path = a.path = b.path = (char*)path;1100oidcpy(&one.oid, o_oid);1101 one.mode = o_mode;1102oidcpy(&a.oid, a_oid);1103 a.mode = a_mode;1104oidcpy(&b.oid, b_oid);1105 b.mode = b_mode;1106returnmerge_file_1(o, &one, &a, &b, branch1, branch2, mfi);1107}11081109static inthandle_change_delete(struct merge_options *o,1110const char*path,const char*old_path,1111const struct object_id *o_oid,int o_mode,1112const struct object_id *changed_oid,1113int changed_mode,1114const char*change_branch,1115const char*delete_branch,1116const char*change,const char*change_past)1117{1118char*alt_path = NULL;1119const char*update_path = path;1120int ret =0;11211122if(dir_in_way(path, !o->call_depth,0)) {1123 update_path = alt_path =unique_path(o, path, change_branch);1124}11251126if(o->call_depth) {1127/*1128 * We cannot arbitrarily accept either a_sha or b_sha as1129 * correct; since there is no true "middle point" between1130 * them, simply reuse the base version for virtual merge base.1131 */1132 ret =remove_file_from_cache(path);1133if(!ret)1134 ret =update_file(o,0, o_oid, o_mode, update_path);1135}else{1136if(!alt_path) {1137if(!old_path) {1138output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1139"and%sin%s. Version%sof%sleft in tree."),1140 change, path, delete_branch, change_past,1141 change_branch, change_branch, path);1142}else{1143output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1144"and%sto%sin%s. Version%sof%sleft in tree."),1145 change, old_path, delete_branch, change_past, path,1146 change_branch, change_branch, path);1147}1148}else{1149if(!old_path) {1150output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1151"and%sin%s. Version%sof%sleft in tree at%s."),1152 change, path, delete_branch, change_past,1153 change_branch, change_branch, path, alt_path);1154}else{1155output(o,1,_("CONFLICT (%s/delete):%sdeleted in%s"1156"and%sto%sin%s. Version%sof%sleft in tree at%s."),1157 change, old_path, delete_branch, change_past, path,1158 change_branch, change_branch, path, alt_path);1159}1160}1161/*1162 * No need to call update_file() on path when change_branch ==1163 * o->branch1 && !alt_path, since that would needlessly touch1164 * path. We could call update_file_flags() with update_cache=01165 * and update_wd=0, but that's a no-op.1166 */1167if(change_branch != o->branch1 || alt_path)1168 ret =update_file(o,0, changed_oid, changed_mode, update_path);1169}1170free(alt_path);11711172return ret;1173}11741175static intconflict_rename_delete(struct merge_options *o,1176struct diff_filepair *pair,1177const char*rename_branch,1178const char*delete_branch)1179{1180const struct diff_filespec *orig = pair->one;1181const struct diff_filespec *dest = pair->two;11821183if(handle_change_delete(o,1184 o->call_depth ? orig->path : dest->path,1185 o->call_depth ? NULL : orig->path,1186&orig->oid, orig->mode,1187&dest->oid, dest->mode,1188 rename_branch, delete_branch,1189_("rename"),_("renamed")))1190return-1;11911192if(o->call_depth)1193returnremove_file_from_cache(dest->path);1194else1195returnupdate_stages(o, dest->path, NULL,1196 rename_branch == o->branch1 ? dest : NULL,1197 rename_branch == o->branch1 ? NULL : dest);1198}11991200static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,1201struct stage_data *entry,1202int stage)1203{1204struct object_id *oid = &entry->stages[stage].oid;1205unsigned mode = entry->stages[stage].mode;1206if(mode ==0||is_null_oid(oid))1207return NULL;1208oidcpy(&target->oid, oid);1209 target->mode = mode;1210return target;1211}12121213static inthandle_file(struct merge_options *o,1214struct diff_filespec *rename,1215int stage,1216struct rename_conflict_info *ci)1217{1218char*dst_name = rename->path;1219struct stage_data *dst_entry;1220const char*cur_branch, *other_branch;1221struct diff_filespec other;1222struct diff_filespec *add;1223int ret;12241225if(stage ==2) {1226 dst_entry = ci->dst_entry1;1227 cur_branch = ci->branch1;1228 other_branch = ci->branch2;1229}else{1230 dst_entry = ci->dst_entry2;1231 cur_branch = ci->branch2;1232 other_branch = ci->branch1;1233}12341235 add =filespec_from_entry(&other, dst_entry, stage ^1);1236if(add) {1237char*add_name =unique_path(o, rename->path, other_branch);1238if(update_file(o,0, &add->oid, add->mode, add_name))1239return-1;12401241remove_file(o,0, rename->path,0);1242 dst_name =unique_path(o, rename->path, cur_branch);1243}else{1244if(dir_in_way(rename->path, !o->call_depth,0)) {1245 dst_name =unique_path(o, rename->path, cur_branch);1246output(o,1,_("%sis a directory in%sadding as%sinstead"),1247 rename->path, other_branch, dst_name);1248}1249}1250if((ret =update_file(o,0, &rename->oid, rename->mode, dst_name)))1251;/* fall through, do allow dst_name to be released */1252else if(stage ==2)1253 ret =update_stages(o, rename->path, NULL, rename, add);1254else1255 ret =update_stages(o, rename->path, NULL, add, rename);12561257if(dst_name != rename->path)1258free(dst_name);12591260return ret;1261}12621263static intconflict_rename_rename_1to2(struct merge_options *o,1264struct rename_conflict_info *ci)1265{1266/* One file was renamed in both branches, but to different names. */1267struct diff_filespec *one = ci->pair1->one;1268struct diff_filespec *a = ci->pair1->two;1269struct diff_filespec *b = ci->pair2->two;12701271output(o,1,_("CONFLICT (rename/rename): "1272"Rename\"%s\"->\"%s\"in branch\"%s\""1273"rename\"%s\"->\"%s\"in\"%s\"%s"),1274 one->path, a->path, ci->branch1,1275 one->path, b->path, ci->branch2,1276 o->call_depth ?_(" (left unresolved)") :"");1277if(o->call_depth) {1278struct merge_file_info mfi;1279struct diff_filespec other;1280struct diff_filespec *add;1281if(merge_file_one(o, one->path,1282&one->oid, one->mode,1283&a->oid, a->mode,1284&b->oid, b->mode,1285 ci->branch1, ci->branch2, &mfi))1286return-1;12871288/*1289 * FIXME: For rename/add-source conflicts (if we could detect1290 * such), this is wrong. We should instead find a unique1291 * pathname and then either rename the add-source file to that1292 * unique path, or use that unique path instead of src here.1293 */1294if(update_file(o,0, &mfi.oid, mfi.mode, one->path))1295return-1;12961297/*1298 * Above, we put the merged content at the merge-base's1299 * path. Now we usually need to delete both a->path and1300 * b->path. However, the rename on each side of the merge1301 * could also be involved in a rename/add conflict. In1302 * such cases, we should keep the added file around,1303 * resolving the conflict at that path in its favor.1304 */1305 add =filespec_from_entry(&other, ci->dst_entry1,2^1);1306if(add) {1307if(update_file(o,0, &add->oid, add->mode, a->path))1308return-1;1309}1310else1311remove_file_from_cache(a->path);1312 add =filespec_from_entry(&other, ci->dst_entry2,3^1);1313if(add) {1314if(update_file(o,0, &add->oid, add->mode, b->path))1315return-1;1316}1317else1318remove_file_from_cache(b->path);1319}else if(handle_file(o, a,2, ci) ||handle_file(o, b,3, ci))1320return-1;13211322return0;1323}13241325static intconflict_rename_rename_2to1(struct merge_options *o,1326struct rename_conflict_info *ci)1327{1328/* Two files, a & b, were renamed to the same thing, c. */1329struct diff_filespec *a = ci->pair1->one;1330struct diff_filespec *b = ci->pair2->one;1331struct diff_filespec *c1 = ci->pair1->two;1332struct diff_filespec *c2 = ci->pair2->two;1333char*path = c1->path;/* == c2->path */1334struct merge_file_info mfi_c1;1335struct merge_file_info mfi_c2;1336int ret;13371338output(o,1,_("CONFLICT (rename/rename): "1339"Rename%s->%sin%s. "1340"Rename%s->%sin%s"),1341 a->path, c1->path, ci->branch1,1342 b->path, c2->path, ci->branch2);13431344remove_file(o,1, a->path, o->call_depth ||would_lose_untracked(a->path));1345remove_file(o,1, b->path, o->call_depth ||would_lose_untracked(b->path));13461347if(merge_file_special_markers(o, a, c1, &ci->ren1_other,1348 o->branch1, c1->path,1349 o->branch2, ci->ren1_other.path, &mfi_c1) ||1350merge_file_special_markers(o, b, &ci->ren2_other, c2,1351 o->branch1, ci->ren2_other.path,1352 o->branch2, c2->path, &mfi_c2))1353return-1;13541355if(o->call_depth) {1356/*1357 * If mfi_c1.clean && mfi_c2.clean, then it might make1358 * sense to do a two-way merge of those results. But, I1359 * think in all cases, it makes sense to have the virtual1360 * merge base just undo the renames; they can be detected1361 * again later for the non-recursive merge.1362 */1363remove_file(o,0, path,0);1364 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, a->path);1365if(!ret)1366 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1367 b->path);1368}else{1369char*new_path1 =unique_path(o, path, ci->branch1);1370char*new_path2 =unique_path(o, path, ci->branch2);1371output(o,1,_("Renaming%sto%sand%sto%sinstead"),1372 a->path, new_path1, b->path, new_path2);1373remove_file(o,0, path,0);1374 ret =update_file(o,0, &mfi_c1.oid, mfi_c1.mode, new_path1);1375if(!ret)1376 ret =update_file(o,0, &mfi_c2.oid, mfi_c2.mode,1377 new_path2);1378free(new_path2);1379free(new_path1);1380}13811382return ret;1383}13841385/*1386 * Get the diff_filepairs changed between o_tree and tree.1387 */1388static struct diff_queue_struct *get_diffpairs(struct merge_options *o,1389struct tree *o_tree,1390struct tree *tree)1391{1392struct diff_queue_struct *ret;1393struct diff_options opts;13941395diff_setup(&opts);1396 opts.flags.recursive =1;1397 opts.flags.rename_empty =0;1398 opts.detect_rename = DIFF_DETECT_RENAME;1399 opts.rename_limit = o->merge_rename_limit >=0? o->merge_rename_limit :1400 o->diff_rename_limit >=0? o->diff_rename_limit :14011000;1402 opts.rename_score = o->rename_score;1403 opts.show_rename_progress = o->show_rename_progress;1404 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1405diff_setup_done(&opts);1406diff_tree_oid(&o_tree->object.oid, &tree->object.oid,"", &opts);1407diffcore_std(&opts);1408if(opts.needed_rename_limit > o->needed_rename_limit)1409 o->needed_rename_limit = opts.needed_rename_limit;14101411 ret =xmalloc(sizeof(*ret));1412*ret = diff_queued_diff;14131414 opts.output_format = DIFF_FORMAT_NO_OUTPUT;1415 diff_queued_diff.nr =0;1416 diff_queued_diff.queue = NULL;1417diff_flush(&opts);1418return ret;1419}14201421static inttree_has_path(struct tree *tree,const char*path)1422{1423struct object_id hashy;1424unsigned int mode_o;14251426return!get_tree_entry(&tree->object.oid, path,1427&hashy, &mode_o);1428}14291430/*1431 * Return a new string that replaces the beginning portion (which matches1432 * entry->dir), with entry->new_dir. In perl-speak:1433 * new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);1434 * NOTE:1435 * Caller must ensure that old_path starts with entry->dir + '/'.1436 */1437static char*apply_dir_rename(struct dir_rename_entry *entry,1438const char*old_path)1439{1440struct strbuf new_path = STRBUF_INIT;1441int oldlen, newlen;14421443if(entry->non_unique_new_dir)1444return NULL;14451446 oldlen =strlen(entry->dir);1447 newlen = entry->new_dir.len + (strlen(old_path) - oldlen) +1;1448strbuf_grow(&new_path, newlen);1449strbuf_addbuf(&new_path, &entry->new_dir);1450strbuf_addstr(&new_path, &old_path[oldlen]);14511452returnstrbuf_detach(&new_path, NULL);1453}14541455static voidget_renamed_dir_portion(const char*old_path,const char*new_path,1456char**old_dir,char**new_dir)1457{1458char*end_of_old, *end_of_new;1459int old_len, new_len;14601461*old_dir = NULL;1462*new_dir = NULL;14631464/*1465 * For1466 * "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"1467 * the "e/foo.c" part is the same, we just want to know that1468 * "a/b/c/d" was renamed to "a/b/some/thing/else"1469 * so, for this example, this function returns "a/b/c/d" in1470 * *old_dir and "a/b/some/thing/else" in *new_dir.1471 *1472 * Also, if the basename of the file changed, we don't care. We1473 * want to know which portion of the directory, if any, changed.1474 */1475 end_of_old =strrchr(old_path,'/');1476 end_of_new =strrchr(new_path,'/');14771478if(end_of_old == NULL || end_of_new == NULL)1479return;1480while(*--end_of_new == *--end_of_old &&1481 end_of_old != old_path &&1482 end_of_new != new_path)1483;/* Do nothing; all in the while loop */1484/*1485 * We've found the first non-matching character in the directory1486 * paths. That means the current directory we were comparing1487 * represents the rename. Move end_of_old and end_of_new back1488 * to the full directory name.1489 */1490if(*end_of_old =='/')1491 end_of_old++;1492if(*end_of_old !='/')1493 end_of_new++;1494 end_of_old =strchr(end_of_old,'/');1495 end_of_new =strchr(end_of_new,'/');14961497/*1498 * It may have been the case that old_path and new_path were the same1499 * directory all along. Don't claim a rename if they're the same.1500 */1501 old_len = end_of_old - old_path;1502 new_len = end_of_new - new_path;15031504if(old_len != new_len ||strncmp(old_path, new_path, old_len)) {1505*old_dir =xstrndup(old_path, old_len);1506*new_dir =xstrndup(new_path, new_len);1507}1508}15091510static voidremove_hashmap_entries(struct hashmap *dir_renames,1511struct string_list *items_to_remove)1512{1513int i;1514struct dir_rename_entry *entry;15151516for(i =0; i < items_to_remove->nr; i++) {1517 entry = items_to_remove->items[i].util;1518hashmap_remove(dir_renames, entry, NULL);1519}1520string_list_clear(items_to_remove,0);1521}15221523/*1524 * See if there is a directory rename for path, and if there are any file1525 * level conflicts for the renamed location. If there is a rename and1526 * there are no conflicts, return the new name. Otherwise, return NULL.1527 */1528static char*handle_path_level_conflicts(struct merge_options *o,1529const char*path,1530struct dir_rename_entry *entry,1531struct hashmap *collisions,1532struct tree *tree)1533{1534char*new_path = NULL;1535struct collision_entry *collision_ent;1536int clean =1;1537struct strbuf collision_paths = STRBUF_INIT;15381539/*1540 * entry has the mapping of old directory name to new directory name1541 * that we want to apply to path.1542 */1543 new_path =apply_dir_rename(entry, path);15441545if(!new_path) {1546/* This should only happen when entry->non_unique_new_dir set */1547if(!entry->non_unique_new_dir)1548BUG("entry->non_unqiue_dir not set and !new_path");1549output(o,1,_("CONFLICT (directory rename split): "1550"Unclear where to place%sbecause directory "1551"%swas renamed to multiple other directories, "1552"with no destination getting a majority of the "1553"files."),1554 path, entry->dir);1555 clean =0;1556return NULL;1557}15581559/*1560 * The caller needs to have ensured that it has pre-populated1561 * collisions with all paths that map to new_path. Do a quick check1562 * to ensure that's the case.1563 */1564 collision_ent =collision_find_entry(collisions, new_path);1565if(collision_ent == NULL)1566BUG("collision_ent is NULL");15671568/*1569 * Check for one-sided add/add/.../add conflicts, i.e.1570 * where implicit renames from the other side doing1571 * directory rename(s) can affect this side of history1572 * to put multiple paths into the same location. Warn1573 * and bail on directory renames for such paths.1574 */1575if(collision_ent->reported_already) {1576 clean =0;1577}else if(tree_has_path(tree, new_path)) {1578 collision_ent->reported_already =1;1579strbuf_add_separated_string_list(&collision_paths,", ",1580&collision_ent->source_files);1581output(o,1,_("CONFLICT (implicit dir rename): Existing "1582"file/dir at%sin the way of implicit "1583"directory rename(s) putting the following "1584"path(s) there:%s."),1585 new_path, collision_paths.buf);1586 clean =0;1587}else if(collision_ent->source_files.nr >1) {1588 collision_ent->reported_already =1;1589strbuf_add_separated_string_list(&collision_paths,", ",1590&collision_ent->source_files);1591output(o,1,_("CONFLICT (implicit dir rename): Cannot map "1592"more than one path to%s; implicit directory "1593"renames tried to put these paths there:%s"),1594 new_path, collision_paths.buf);1595 clean =0;1596}15971598/* Free memory we no longer need */1599strbuf_release(&collision_paths);1600if(!clean && new_path) {1601free(new_path);1602return NULL;1603}16041605return new_path;1606}16071608/*1609 * There are a couple things we want to do at the directory level:1610 * 1. Check for both sides renaming to the same thing, in order to avoid1611 * implicit renaming of files that should be left in place. (See1612 * testcase 6b in t6043 for details.)1613 * 2. Prune directory renames if there are still files left in the1614 * the original directory. These represent a partial directory rename,1615 * i.e. a rename where only some of the files within the directory1616 * were renamed elsewhere. (Technically, this could be done earlier1617 * in get_directory_renames(), except that would prevent us from1618 * doing the previous check and thus failing testcase 6b.)1619 * 3. Check for rename/rename(1to2) conflicts (at the directory level).1620 * In the future, we could potentially record this info as well and1621 * omit reporting rename/rename(1to2) conflicts for each path within1622 * the affected directories, thus cleaning up the merge output.1623 * NOTE: We do NOT check for rename/rename(2to1) conflicts at the1624 * directory level, because merging directories is fine. If it1625 * causes conflicts for files within those merged directories, then1626 * that should be detected at the individual path level.1627 */1628static voidhandle_directory_level_conflicts(struct merge_options *o,1629struct hashmap *dir_re_head,1630struct tree *head,1631struct hashmap *dir_re_merge,1632struct tree *merge)1633{1634struct hashmap_iter iter;1635struct dir_rename_entry *head_ent;1636struct dir_rename_entry *merge_ent;16371638struct string_list remove_from_head = STRING_LIST_INIT_NODUP;1639struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;16401641hashmap_iter_init(dir_re_head, &iter);1642while((head_ent =hashmap_iter_next(&iter))) {1643 merge_ent =dir_rename_find_entry(dir_re_merge, head_ent->dir);1644if(merge_ent &&1645!head_ent->non_unique_new_dir &&1646!merge_ent->non_unique_new_dir &&1647!strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {1648/* 1. Renamed identically; remove it from both sides */1649string_list_append(&remove_from_head,1650 head_ent->dir)->util = head_ent;1651strbuf_release(&head_ent->new_dir);1652string_list_append(&remove_from_merge,1653 merge_ent->dir)->util = merge_ent;1654strbuf_release(&merge_ent->new_dir);1655}else if(tree_has_path(head, head_ent->dir)) {1656/* 2. This wasn't a directory rename after all */1657string_list_append(&remove_from_head,1658 head_ent->dir)->util = head_ent;1659strbuf_release(&head_ent->new_dir);1660}1661}16621663remove_hashmap_entries(dir_re_head, &remove_from_head);1664remove_hashmap_entries(dir_re_merge, &remove_from_merge);16651666hashmap_iter_init(dir_re_merge, &iter);1667while((merge_ent =hashmap_iter_next(&iter))) {1668 head_ent =dir_rename_find_entry(dir_re_head, merge_ent->dir);1669if(tree_has_path(merge, merge_ent->dir)) {1670/* 2. This wasn't a directory rename after all */1671string_list_append(&remove_from_merge,1672 merge_ent->dir)->util = merge_ent;1673}else if(head_ent &&1674!head_ent->non_unique_new_dir &&1675!merge_ent->non_unique_new_dir) {1676/* 3. rename/rename(1to2) */1677/*1678 * We can assume it's not rename/rename(1to1) because1679 * that was case (1), already checked above. So we1680 * know that head_ent->new_dir and merge_ent->new_dir1681 * are different strings.1682 */1683output(o,1,_("CONFLICT (rename/rename): "1684"Rename directory%s->%sin%s. "1685"Rename directory%s->%sin%s"),1686 head_ent->dir, head_ent->new_dir.buf, o->branch1,1687 head_ent->dir, merge_ent->new_dir.buf, o->branch2);1688string_list_append(&remove_from_head,1689 head_ent->dir)->util = head_ent;1690strbuf_release(&head_ent->new_dir);1691string_list_append(&remove_from_merge,1692 merge_ent->dir)->util = merge_ent;1693strbuf_release(&merge_ent->new_dir);1694}1695}16961697remove_hashmap_entries(dir_re_head, &remove_from_head);1698remove_hashmap_entries(dir_re_merge, &remove_from_merge);1699}17001701static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,1702struct tree *tree)1703{1704struct hashmap *dir_renames;1705struct hashmap_iter iter;1706struct dir_rename_entry *entry;1707int i;17081709/*1710 * Typically, we think of a directory rename as all files from a1711 * certain directory being moved to a target directory. However,1712 * what if someone first moved two files from the original1713 * directory in one commit, and then renamed the directory1714 * somewhere else in a later commit? At merge time, we just know1715 * that files from the original directory went to two different1716 * places, and that the bulk of them ended up in the same place.1717 * We want each directory rename to represent where the bulk of the1718 * files from that directory end up; this function exists to find1719 * where the bulk of the files went.1720 *1721 * The first loop below simply iterates through the list of file1722 * renames, finding out how often each directory rename pair1723 * possibility occurs.1724 */1725 dir_renames =xmalloc(sizeof(*dir_renames));1726dir_rename_init(dir_renames);1727for(i =0; i < pairs->nr; ++i) {1728struct string_list_item *item;1729int*count;1730struct diff_filepair *pair = pairs->queue[i];1731char*old_dir, *new_dir;17321733/* File not part of directory rename if it wasn't renamed */1734if(pair->status !='R')1735continue;17361737get_renamed_dir_portion(pair->one->path, pair->two->path,1738&old_dir, &new_dir);1739if(!old_dir)1740/* Directory didn't change at all; ignore this one. */1741continue;17421743 entry =dir_rename_find_entry(dir_renames, old_dir);1744if(!entry) {1745 entry =xmalloc(sizeof(*entry));1746dir_rename_entry_init(entry, old_dir);1747hashmap_put(dir_renames, entry);1748}else{1749free(old_dir);1750}1751 item =string_list_lookup(&entry->possible_new_dirs, new_dir);1752if(!item) {1753 item =string_list_insert(&entry->possible_new_dirs,1754 new_dir);1755 item->util =xcalloc(1,sizeof(int));1756}else{1757free(new_dir);1758}1759 count = item->util;1760*count +=1;1761}17621763/*1764 * For each directory with files moved out of it, we find out which1765 * target directory received the most files so we can declare it to1766 * be the "winning" target location for the directory rename. This1767 * winner gets recorded in new_dir. If there is no winner1768 * (multiple target directories received the same number of files),1769 * we set non_unique_new_dir. Once we've determined the winner (or1770 * that there is no winner), we no longer need possible_new_dirs.1771 */1772hashmap_iter_init(dir_renames, &iter);1773while((entry =hashmap_iter_next(&iter))) {1774int max =0;1775int bad_max =0;1776char*best = NULL;17771778for(i =0; i < entry->possible_new_dirs.nr; i++) {1779int*count = entry->possible_new_dirs.items[i].util;17801781if(*count == max)1782 bad_max = max;1783else if(*count > max) {1784 max = *count;1785 best = entry->possible_new_dirs.items[i].string;1786}1787}1788if(bad_max == max)1789 entry->non_unique_new_dir =1;1790else{1791assert(entry->new_dir.len ==0);1792strbuf_addstr(&entry->new_dir, best);1793}1794/*1795 * The relevant directory sub-portion of the original full1796 * filepaths were xstrndup'ed before inserting into1797 * possible_new_dirs, and instead of manually iterating the1798 * list and free'ing each, just lie and tell1799 * possible_new_dirs that it did the strdup'ing so that it1800 * will free them for us.1801 */1802 entry->possible_new_dirs.strdup_strings =1;1803string_list_clear(&entry->possible_new_dirs,1);1804}18051806return dir_renames;1807}18081809static struct dir_rename_entry *check_dir_renamed(const char*path,1810struct hashmap *dir_renames)1811{1812char temp[PATH_MAX];1813char*end;1814struct dir_rename_entry *entry;18151816strcpy(temp, path);1817while((end =strrchr(temp,'/'))) {1818*end ='\0';1819 entry =dir_rename_find_entry(dir_renames, temp);1820if(entry)1821return entry;1822}1823return NULL;1824}18251826static voidcompute_collisions(struct hashmap *collisions,1827struct hashmap *dir_renames,1828struct diff_queue_struct *pairs)1829{1830int i;18311832/*1833 * Multiple files can be mapped to the same path due to directory1834 * renames done by the other side of history. Since that other1835 * side of history could have merged multiple directories into one,1836 * if our side of history added the same file basename to each of1837 * those directories, then all N of them would get implicitly1838 * renamed by the directory rename detection into the same path,1839 * and we'd get an add/add/.../add conflict, and all those adds1840 * from *this* side of history. This is not representable in the1841 * index, and users aren't going to easily be able to make sense of1842 * it. So we need to provide a good warning about what's1843 * happening, and fall back to no-directory-rename detection1844 * behavior for those paths.1845 *1846 * See testcases 9e and all of section 5 from t6043 for examples.1847 */1848collision_init(collisions);18491850for(i =0; i < pairs->nr; ++i) {1851struct dir_rename_entry *dir_rename_ent;1852struct collision_entry *collision_ent;1853char*new_path;1854struct diff_filepair *pair = pairs->queue[i];18551856if(pair->status =='D')1857continue;1858 dir_rename_ent =check_dir_renamed(pair->two->path,1859 dir_renames);1860if(!dir_rename_ent)1861continue;18621863 new_path =apply_dir_rename(dir_rename_ent, pair->two->path);1864if(!new_path)1865/*1866 * dir_rename_ent->non_unique_new_path is true, which1867 * means there is no directory rename for us to use,1868 * which means it won't cause us any additional1869 * collisions.1870 */1871continue;1872 collision_ent =collision_find_entry(collisions, new_path);1873if(!collision_ent) {1874 collision_ent =xcalloc(1,1875sizeof(struct collision_entry));1876hashmap_entry_init(collision_ent,strhash(new_path));1877hashmap_put(collisions, collision_ent);1878 collision_ent->target_file = new_path;1879}else{1880free(new_path);1881}1882string_list_insert(&collision_ent->source_files,1883 pair->two->path);1884}1885}18861887static char*check_for_directory_rename(struct merge_options *o,1888const char*path,1889struct tree *tree,1890struct hashmap *dir_renames,1891struct hashmap *dir_rename_exclusions,1892struct hashmap *collisions,1893int*clean_merge)1894{1895char*new_path = NULL;1896struct dir_rename_entry *entry =check_dir_renamed(path, dir_renames);1897struct dir_rename_entry *oentry = NULL;18981899if(!entry)1900return new_path;19011902/*1903 * This next part is a little weird. We do not want to do an1904 * implicit rename into a directory we renamed on our side, because1905 * that will result in a spurious rename/rename(1to2) conflict. An1906 * example:1907 * Base commit: dumbdir/afile, otherdir/bfile1908 * Side 1: smrtdir/afile, otherdir/bfile1909 * Side 2: dumbdir/afile, dumbdir/bfile1910 * Here, while working on Side 1, we could notice that otherdir was1911 * renamed/merged to dumbdir, and change the diff_filepair for1912 * otherdir/bfile into a rename into dumbdir/bfile. However, Side1913 * 2 will notice the rename from dumbdir to smrtdir, and do the1914 * transitive rename to move it from dumbdir/bfile to1915 * smrtdir/bfile. That gives us bfile in dumbdir vs being in1916 * smrtdir, a rename/rename(1to2) conflict. We really just want1917 * the file to end up in smrtdir. And the way to achieve that is1918 * to not let Side1 do the rename to dumbdir, since we know that is1919 * the source of one of our directory renames.1920 *1921 * That's why oentry and dir_rename_exclusions is here.1922 *1923 * As it turns out, this also prevents N-way transient rename1924 * confusion; See testcases 9c and 9d of t6043.1925 */1926 oentry =dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);1927if(oentry) {1928output(o,1,_("WARNING: Avoiding applying%s->%srename "1929"to%s, because%sitself was renamed."),1930 entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);1931}else{1932 new_path =handle_path_level_conflicts(o, path, entry,1933 collisions, tree);1934*clean_merge &= (new_path != NULL);1935}19361937return new_path;1938}19391940/*1941 * Get information of all renames which occurred in 'pairs', making use of1942 * any implicit directory renames inferred from the other side of history.1943 * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')1944 * to be able to associate the correct cache entries with the rename1945 * information; tree is always equal to either a_tree or b_tree.1946 */1947static struct string_list *get_renames(struct merge_options *o,1948struct diff_queue_struct *pairs,1949struct hashmap *dir_renames,1950struct hashmap *dir_rename_exclusions,1951struct tree *tree,1952struct tree *o_tree,1953struct tree *a_tree,1954struct tree *b_tree,1955struct string_list *entries,1956int*clean_merge)1957{1958int i;1959struct hashmap collisions;1960struct hashmap_iter iter;1961struct collision_entry *e;1962struct string_list *renames;19631964compute_collisions(&collisions, dir_renames, pairs);1965 renames =xcalloc(1,sizeof(struct string_list));19661967for(i =0; i < pairs->nr; ++i) {1968struct string_list_item *item;1969struct rename *re;1970struct diff_filepair *pair = pairs->queue[i];1971char*new_path;/* non-NULL only with directory renames */19721973if(pair->status =='D') {1974diff_free_filepair(pair);1975continue;1976}1977 new_path =check_for_directory_rename(o, pair->two->path, tree,1978 dir_renames,1979 dir_rename_exclusions,1980&collisions,1981 clean_merge);1982if(pair->status !='R'&& !new_path) {1983diff_free_filepair(pair);1984continue;1985}19861987 re =xmalloc(sizeof(*re));1988 re->processed =0;1989 re->pair = pair;1990 item =string_list_lookup(entries, re->pair->one->path);1991if(!item)1992 re->src_entry =insert_stage_data(re->pair->one->path,1993 o_tree, a_tree, b_tree, entries);1994else1995 re->src_entry = item->util;19961997 item =string_list_lookup(entries, re->pair->two->path);1998if(!item)1999 re->dst_entry =insert_stage_data(re->pair->two->path,2000 o_tree, a_tree, b_tree, entries);2001else2002 re->dst_entry = item->util;2003 item =string_list_insert(renames, pair->one->path);2004 item->util = re;2005}20062007hashmap_iter_init(&collisions, &iter);2008while((e =hashmap_iter_next(&iter))) {2009free(e->target_file);2010string_list_clear(&e->source_files,0);2011}2012hashmap_free(&collisions,1);2013return renames;2014}20152016static intprocess_renames(struct merge_options *o,2017struct string_list *a_renames,2018struct string_list *b_renames)2019{2020int clean_merge =1, i, j;2021struct string_list a_by_dst = STRING_LIST_INIT_NODUP;2022struct string_list b_by_dst = STRING_LIST_INIT_NODUP;2023const struct rename *sre;20242025for(i =0; i < a_renames->nr; i++) {2026 sre = a_renames->items[i].util;2027string_list_insert(&a_by_dst, sre->pair->two->path)->util2028= (void*)sre;2029}2030for(i =0; i < b_renames->nr; i++) {2031 sre = b_renames->items[i].util;2032string_list_insert(&b_by_dst, sre->pair->two->path)->util2033= (void*)sre;2034}20352036for(i =0, j =0; i < a_renames->nr || j < b_renames->nr;) {2037struct string_list *renames1, *renames2Dst;2038struct rename *ren1 = NULL, *ren2 = NULL;2039const char*branch1, *branch2;2040const char*ren1_src, *ren1_dst;2041struct string_list_item *lookup;20422043if(i >= a_renames->nr) {2044 ren2 = b_renames->items[j++].util;2045}else if(j >= b_renames->nr) {2046 ren1 = a_renames->items[i++].util;2047}else{2048int compare =strcmp(a_renames->items[i].string,2049 b_renames->items[j].string);2050if(compare <=0)2051 ren1 = a_renames->items[i++].util;2052if(compare >=0)2053 ren2 = b_renames->items[j++].util;2054}20552056/* TODO: refactor, so that 1/2 are not needed */2057if(ren1) {2058 renames1 = a_renames;2059 renames2Dst = &b_by_dst;2060 branch1 = o->branch1;2061 branch2 = o->branch2;2062}else{2063 renames1 = b_renames;2064 renames2Dst = &a_by_dst;2065 branch1 = o->branch2;2066 branch2 = o->branch1;2067SWAP(ren2, ren1);2068}20692070if(ren1->processed)2071continue;2072 ren1->processed =1;2073 ren1->dst_entry->processed =1;2074/* BUG: We should only mark src_entry as processed if we2075 * are not dealing with a rename + add-source case.2076 */2077 ren1->src_entry->processed =1;20782079 ren1_src = ren1->pair->one->path;2080 ren1_dst = ren1->pair->two->path;20812082if(ren2) {2083/* One file renamed on both sides */2084const char*ren2_src = ren2->pair->one->path;2085const char*ren2_dst = ren2->pair->two->path;2086enum rename_type rename_type;2087if(strcmp(ren1_src, ren2_src) !=0)2088die("BUG: ren1_src != ren2_src");2089 ren2->dst_entry->processed =1;2090 ren2->processed =1;2091if(strcmp(ren1_dst, ren2_dst) !=0) {2092 rename_type = RENAME_ONE_FILE_TO_TWO;2093 clean_merge =0;2094}else{2095 rename_type = RENAME_ONE_FILE_TO_ONE;2096/* BUG: We should only remove ren1_src in2097 * the base stage (think of rename +2098 * add-source cases).2099 */2100remove_file(o,1, ren1_src,1);2101update_entry(ren1->dst_entry,2102 ren1->pair->one,2103 ren1->pair->two,2104 ren2->pair->two);2105}2106setup_rename_conflict_info(rename_type,2107 ren1->pair,2108 ren2->pair,2109 branch1,2110 branch2,2111 ren1->dst_entry,2112 ren2->dst_entry,2113 o,2114 NULL,2115 NULL);2116}else if((lookup =string_list_lookup(renames2Dst, ren1_dst))) {2117/* Two different files renamed to the same thing */2118char*ren2_dst;2119 ren2 = lookup->util;2120 ren2_dst = ren2->pair->two->path;2121if(strcmp(ren1_dst, ren2_dst) !=0)2122die("BUG: ren1_dst != ren2_dst");21232124 clean_merge =0;2125 ren2->processed =1;2126/*2127 * BUG: We should only mark src_entry as processed2128 * if we are not dealing with a rename + add-source2129 * case.2130 */2131 ren2->src_entry->processed =1;21322133setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,2134 ren1->pair,2135 ren2->pair,2136 branch1,2137 branch2,2138 ren1->dst_entry,2139 ren2->dst_entry,2140 o,2141 ren1->src_entry,2142 ren2->src_entry);21432144}else{2145/* Renamed in 1, maybe changed in 2 */2146/* we only use sha1 and mode of these */2147struct diff_filespec src_other, dst_other;2148int try_merge;21492150/*2151 * unpack_trees loads entries from common-commit2152 * into stage 1, from head-commit into stage 2, and2153 * from merge-commit into stage 3. We keep track2154 * of which side corresponds to the rename.2155 */2156int renamed_stage = a_renames == renames1 ?2:3;2157int other_stage = a_renames == renames1 ?3:2;21582159/* BUG: We should only remove ren1_src in the base2160 * stage and in other_stage (think of rename +2161 * add-source case).2162 */2163remove_file(o,1, ren1_src,2164 renamed_stage ==2|| !was_tracked(ren1_src));21652166oidcpy(&src_other.oid,2167&ren1->src_entry->stages[other_stage].oid);2168 src_other.mode = ren1->src_entry->stages[other_stage].mode;2169oidcpy(&dst_other.oid,2170&ren1->dst_entry->stages[other_stage].oid);2171 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;2172 try_merge =0;21732174if(oid_eq(&src_other.oid, &null_oid)) {2175setup_rename_conflict_info(RENAME_DELETE,2176 ren1->pair,2177 NULL,2178 branch1,2179 branch2,2180 ren1->dst_entry,2181 NULL,2182 o,2183 NULL,2184 NULL);2185}else if((dst_other.mode == ren1->pair->two->mode) &&2186oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {2187/*2188 * Added file on the other side identical to2189 * the file being renamed: clean merge.2190 * Also, there is no need to overwrite the2191 * file already in the working copy, so call2192 * update_file_flags() instead of2193 * update_file().2194 */2195if(update_file_flags(o,2196&ren1->pair->two->oid,2197 ren1->pair->two->mode,2198 ren1_dst,21991,/* update_cache */22000/* update_wd */))2201 clean_merge = -1;2202}else if(!oid_eq(&dst_other.oid, &null_oid)) {2203 clean_merge =0;2204 try_merge =1;2205output(o,1,_("CONFLICT (rename/add): Rename%s->%sin%s. "2206"%sadded in%s"),2207 ren1_src, ren1_dst, branch1,2208 ren1_dst, branch2);2209if(o->call_depth) {2210struct merge_file_info mfi;2211if(merge_file_one(o, ren1_dst, &null_oid,0,2212&ren1->pair->two->oid,2213 ren1->pair->two->mode,2214&dst_other.oid,2215 dst_other.mode,2216 branch1, branch2, &mfi)) {2217 clean_merge = -1;2218goto cleanup_and_return;2219}2220output(o,1,_("Adding merged%s"), ren1_dst);2221if(update_file(o,0, &mfi.oid,2222 mfi.mode, ren1_dst))2223 clean_merge = -1;2224 try_merge =0;2225}else{2226char*new_path =unique_path(o, ren1_dst, branch2);2227output(o,1,_("Adding as%sinstead"), new_path);2228if(update_file(o,0, &dst_other.oid,2229 dst_other.mode, new_path))2230 clean_merge = -1;2231free(new_path);2232}2233}else2234 try_merge =1;22352236if(clean_merge <0)2237goto cleanup_and_return;2238if(try_merge) {2239struct diff_filespec *one, *a, *b;2240 src_other.path = (char*)ren1_src;22412242 one = ren1->pair->one;2243if(a_renames == renames1) {2244 a = ren1->pair->two;2245 b = &src_other;2246}else{2247 b = ren1->pair->two;2248 a = &src_other;2249}2250update_entry(ren1->dst_entry, one, a, b);2251setup_rename_conflict_info(RENAME_NORMAL,2252 ren1->pair,2253 NULL,2254 branch1,2255 NULL,2256 ren1->dst_entry,2257 NULL,2258 o,2259 NULL,2260 NULL);2261}2262}2263}2264cleanup_and_return:2265string_list_clear(&a_by_dst,0);2266string_list_clear(&b_by_dst,0);22672268return clean_merge;2269}22702271struct rename_info {2272struct string_list *head_renames;2273struct string_list *merge_renames;2274};22752276static voidinitial_cleanup_rename(struct diff_queue_struct *pairs,2277struct hashmap *dir_renames)2278{2279struct hashmap_iter iter;2280struct dir_rename_entry *e;22812282hashmap_iter_init(dir_renames, &iter);2283while((e =hashmap_iter_next(&iter))) {2284free(e->dir);2285strbuf_release(&e->new_dir);2286/* possible_new_dirs already cleared in get_directory_renames */2287}2288hashmap_free(dir_renames,1);2289free(dir_renames);22902291free(pairs->queue);2292free(pairs);2293}22942295static inthandle_renames(struct merge_options *o,2296struct tree *common,2297struct tree *head,2298struct tree *merge,2299struct string_list *entries,2300struct rename_info *ri)2301{2302struct diff_queue_struct *head_pairs, *merge_pairs;2303struct hashmap *dir_re_head, *dir_re_merge;2304int clean =1;23052306 ri->head_renames = NULL;2307 ri->merge_renames = NULL;23082309if(!o->detect_rename)2310return1;23112312 head_pairs =get_diffpairs(o, common, head);2313 merge_pairs =get_diffpairs(o, common, merge);23142315 dir_re_head =get_directory_renames(head_pairs, head);2316 dir_re_merge =get_directory_renames(merge_pairs, merge);23172318handle_directory_level_conflicts(o,2319 dir_re_head, head,2320 dir_re_merge, merge);23212322 ri->head_renames =get_renames(o, head_pairs,2323 dir_re_merge, dir_re_head, head,2324 common, head, merge, entries,2325&clean);2326if(clean <0)2327goto cleanup;2328 ri->merge_renames =get_renames(o, merge_pairs,2329 dir_re_head, dir_re_merge, merge,2330 common, head, merge, entries,2331&clean);2332if(clean <0)2333goto cleanup;2334 clean &=process_renames(o, ri->head_renames, ri->merge_renames);23352336cleanup:2337/*2338 * Some cleanup is deferred until cleanup_renames() because the2339 * data structures are still needed and referenced in2340 * process_entry(). But there are a few things we can free now.2341 */2342initial_cleanup_rename(head_pairs, dir_re_head);2343initial_cleanup_rename(merge_pairs, dir_re_merge);23442345return clean;2346}23472348static voidfinal_cleanup_rename(struct string_list *rename)2349{2350const struct rename *re;2351int i;23522353if(rename == NULL)2354return;23552356for(i =0; i < rename->nr; i++) {2357 re = rename->items[i].util;2358diff_free_filepair(re->pair);2359}2360string_list_clear(rename,1);2361free(rename);2362}23632364static voidfinal_cleanup_renames(struct rename_info *re_info)2365{2366final_cleanup_rename(re_info->head_renames);2367final_cleanup_rename(re_info->merge_renames);2368}23692370static struct object_id *stage_oid(const struct object_id *oid,unsigned mode)2371{2372return(is_null_oid(oid) || mode ==0) ? NULL: (struct object_id *)oid;2373}23742375static intread_oid_strbuf(struct merge_options *o,2376const struct object_id *oid,struct strbuf *dst)2377{2378void*buf;2379enum object_type type;2380unsigned long size;2381 buf =read_object_file(oid, &type, &size);2382if(!buf)2383returnerr(o,_("cannot read object%s"),oid_to_hex(oid));2384if(type != OBJ_BLOB) {2385free(buf);2386returnerr(o,_("object%sis not a blob"),oid_to_hex(oid));2387}2388strbuf_attach(dst, buf, size, size +1);2389return0;2390}23912392static intblob_unchanged(struct merge_options *opt,2393const struct object_id *o_oid,2394unsigned o_mode,2395const struct object_id *a_oid,2396unsigned a_mode,2397int renormalize,const char*path)2398{2399struct strbuf o = STRBUF_INIT;2400struct strbuf a = STRBUF_INIT;2401int ret =0;/* assume changed for safety */24022403if(a_mode != o_mode)2404return0;2405if(oid_eq(o_oid, a_oid))2406return1;2407if(!renormalize)2408return0;24092410assert(o_oid && a_oid);2411if(read_oid_strbuf(opt, o_oid, &o) ||read_oid_strbuf(opt, a_oid, &a))2412goto error_return;2413/*2414 * Note: binary | is used so that both renormalizations are2415 * performed. Comparison can be skipped if both files are2416 * unchanged since their sha1s have already been compared.2417 */2418if(renormalize_buffer(&the_index, path, o.buf, o.len, &o) |2419renormalize_buffer(&the_index, path, a.buf, a.len, &a))2420 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));24212422error_return:2423strbuf_release(&o);2424strbuf_release(&a);2425return ret;2426}24272428static inthandle_modify_delete(struct merge_options *o,2429const char*path,2430struct object_id *o_oid,int o_mode,2431struct object_id *a_oid,int a_mode,2432struct object_id *b_oid,int b_mode)2433{2434const char*modify_branch, *delete_branch;2435struct object_id *changed_oid;2436int changed_mode;24372438if(a_oid) {2439 modify_branch = o->branch1;2440 delete_branch = o->branch2;2441 changed_oid = a_oid;2442 changed_mode = a_mode;2443}else{2444 modify_branch = o->branch2;2445 delete_branch = o->branch1;2446 changed_oid = b_oid;2447 changed_mode = b_mode;2448}24492450returnhandle_change_delete(o,2451 path, NULL,2452 o_oid, o_mode,2453 changed_oid, changed_mode,2454 modify_branch, delete_branch,2455_("modify"),_("modified"));2456}24572458static intmerge_content(struct merge_options *o,2459const char*path,2460struct object_id *o_oid,int o_mode,2461struct object_id *a_oid,int a_mode,2462struct object_id *b_oid,int b_mode,2463struct rename_conflict_info *rename_conflict_info)2464{2465const char*reason =_("content");2466const char*path1 = NULL, *path2 = NULL;2467struct merge_file_info mfi;2468struct diff_filespec one, a, b;2469unsigned df_conflict_remains =0;24702471if(!o_oid) {2472 reason =_("add/add");2473 o_oid = (struct object_id *)&null_oid;2474}2475 one.path = a.path = b.path = (char*)path;2476oidcpy(&one.oid, o_oid);2477 one.mode = o_mode;2478oidcpy(&a.oid, a_oid);2479 a.mode = a_mode;2480oidcpy(&b.oid, b_oid);2481 b.mode = b_mode;24822483if(rename_conflict_info) {2484struct diff_filepair *pair1 = rename_conflict_info->pair1;24852486 path1 = (o->branch1 == rename_conflict_info->branch1) ?2487 pair1->two->path : pair1->one->path;2488/* If rename_conflict_info->pair2 != NULL, we are in2489 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a2490 * normal rename.2491 */2492 path2 = (rename_conflict_info->pair2 ||2493 o->branch2 == rename_conflict_info->branch1) ?2494 pair1->two->path : pair1->one->path;24952496if(dir_in_way(path, !o->call_depth,2497S_ISGITLINK(pair1->two->mode)))2498 df_conflict_remains =1;2499}2500if(merge_file_special_markers(o, &one, &a, &b,2501 o->branch1, path1,2502 o->branch2, path2, &mfi))2503return-1;25042505if(mfi.clean && !df_conflict_remains &&2506oid_eq(&mfi.oid, a_oid) && mfi.mode == a_mode) {2507int path_renamed_outside_HEAD;2508output(o,3,_("Skipped%s(merged same as existing)"), path);2509/*2510 * The content merge resulted in the same file contents we2511 * already had. We can return early if those file contents2512 * are recorded at the correct path (which may not be true2513 * if the merge involves a rename).2514 */2515 path_renamed_outside_HEAD = !path2 || !strcmp(path, path2);2516if(!path_renamed_outside_HEAD) {2517add_cacheinfo(o, mfi.mode, &mfi.oid, path,25180, (!o->call_depth),0);2519return mfi.clean;2520}2521}else2522output(o,2,_("Auto-merging%s"), path);25232524if(!mfi.clean) {2525if(S_ISGITLINK(mfi.mode))2526 reason =_("submodule");2527output(o,1,_("CONFLICT (%s): Merge conflict in%s"),2528 reason, path);2529if(rename_conflict_info && !df_conflict_remains)2530if(update_stages(o, path, &one, &a, &b))2531return-1;2532}25332534if(df_conflict_remains) {2535char*new_path;2536if(o->call_depth) {2537remove_file_from_cache(path);2538}else{2539if(!mfi.clean) {2540if(update_stages(o, path, &one, &a, &b))2541return-1;2542}else{2543int file_from_stage2 =was_tracked(path);2544struct diff_filespec merged;2545oidcpy(&merged.oid, &mfi.oid);2546 merged.mode = mfi.mode;25472548if(update_stages(o, path, NULL,2549 file_from_stage2 ? &merged : NULL,2550 file_from_stage2 ? NULL : &merged))2551return-1;2552}25532554}2555 new_path =unique_path(o, path, rename_conflict_info->branch1);2556output(o,1,_("Adding as%sinstead"), new_path);2557if(update_file(o,0, &mfi.oid, mfi.mode, new_path)) {2558free(new_path);2559return-1;2560}2561free(new_path);2562 mfi.clean =0;2563}else if(update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))2564return-1;2565return mfi.clean;2566}25672568/* Per entry merge function */2569static intprocess_entry(struct merge_options *o,2570const char*path,struct stage_data *entry)2571{2572int clean_merge =1;2573int normalize = o->renormalize;2574unsigned o_mode = entry->stages[1].mode;2575unsigned a_mode = entry->stages[2].mode;2576unsigned b_mode = entry->stages[3].mode;2577struct object_id *o_oid =stage_oid(&entry->stages[1].oid, o_mode);2578struct object_id *a_oid =stage_oid(&entry->stages[2].oid, a_mode);2579struct object_id *b_oid =stage_oid(&entry->stages[3].oid, b_mode);25802581 entry->processed =1;2582if(entry->rename_conflict_info) {2583struct rename_conflict_info *conflict_info = entry->rename_conflict_info;2584switch(conflict_info->rename_type) {2585case RENAME_NORMAL:2586case RENAME_ONE_FILE_TO_ONE:2587 clean_merge =merge_content(o, path,2588 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,2589 conflict_info);2590break;2591case RENAME_DELETE:2592 clean_merge =0;2593if(conflict_rename_delete(o,2594 conflict_info->pair1,2595 conflict_info->branch1,2596 conflict_info->branch2))2597 clean_merge = -1;2598break;2599case RENAME_ONE_FILE_TO_TWO:2600 clean_merge =0;2601if(conflict_rename_rename_1to2(o, conflict_info))2602 clean_merge = -1;2603break;2604case RENAME_TWO_FILES_TO_ONE:2605 clean_merge =0;2606if(conflict_rename_rename_2to1(o, conflict_info))2607 clean_merge = -1;2608break;2609default:2610 entry->processed =0;2611break;2612}2613}else if(o_oid && (!a_oid || !b_oid)) {2614/* Case A: Deleted in one */2615if((!a_oid && !b_oid) ||2616(!b_oid &&blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||2617(!a_oid &&blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {2618/* Deleted in both or deleted in one and2619 * unchanged in the other */2620if(a_oid)2621output(o,2,_("Removing%s"), path);2622/* do not touch working file if it did not exist */2623remove_file(o,1, path, !a_oid);2624}else{2625/* Modify/delete; deleted side may have put a directory in the way */2626 clean_merge =0;2627if(handle_modify_delete(o, path, o_oid, o_mode,2628 a_oid, a_mode, b_oid, b_mode))2629 clean_merge = -1;2630}2631}else if((!o_oid && a_oid && !b_oid) ||2632(!o_oid && !a_oid && b_oid)) {2633/* Case B: Added in one. */2634/* [nothing|directory] -> ([nothing|directory], file) */26352636const char*add_branch;2637const char*other_branch;2638unsigned mode;2639const struct object_id *oid;2640const char*conf;26412642if(a_oid) {2643 add_branch = o->branch1;2644 other_branch = o->branch2;2645 mode = a_mode;2646 oid = a_oid;2647 conf =_("file/directory");2648}else{2649 add_branch = o->branch2;2650 other_branch = o->branch1;2651 mode = b_mode;2652 oid = b_oid;2653 conf =_("directory/file");2654}2655if(dir_in_way(path,2656!o->call_depth && !S_ISGITLINK(a_mode),26570)) {2658char*new_path =unique_path(o, path, add_branch);2659 clean_merge =0;2660output(o,1,_("CONFLICT (%s): There is a directory with name%sin%s. "2661"Adding%sas%s"),2662 conf, path, other_branch, path, new_path);2663if(update_file(o,0, oid, mode, new_path))2664 clean_merge = -1;2665else if(o->call_depth)2666remove_file_from_cache(path);2667free(new_path);2668}else{2669output(o,2,_("Adding%s"), path);2670/* do not overwrite file if already present */2671if(update_file_flags(o, oid, mode, path,1, !a_oid))2672 clean_merge = -1;2673}2674}else if(a_oid && b_oid) {2675/* Case C: Added in both (check for same permissions) and */2676/* case D: Modified in both, but differently. */2677 clean_merge =merge_content(o, path,2678 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,2679 NULL);2680}else if(!o_oid && !a_oid && !b_oid) {2681/*2682 * this entry was deleted altogether. a_mode == 0 means2683 * we had that path and want to actively remove it.2684 */2685remove_file(o,1, path, !a_mode);2686}else2687die("BUG: fatal merge failure, shouldn't happen.");26882689return clean_merge;2690}26912692intmerge_trees(struct merge_options *o,2693struct tree *head,2694struct tree *merge,2695struct tree *common,2696struct tree **result)2697{2698int code, clean;26992700if(o->subtree_shift) {2701 merge =shift_tree_object(head, merge, o->subtree_shift);2702 common =shift_tree_object(head, common, o->subtree_shift);2703}27042705if(oid_eq(&common->object.oid, &merge->object.oid)) {2706struct strbuf sb = STRBUF_INIT;27072708if(!o->call_depth &&index_has_changes(&sb)) {2709err(o,_("Dirty index: cannot merge (dirty:%s)"),2710 sb.buf);2711return0;2712}2713output(o,0,_("Already up to date!"));2714*result = head;2715return1;2716}27172718 code =git_merge_trees(o->call_depth, common, head, merge);27192720if(code !=0) {2721if(show(o,4) || o->call_depth)2722err(o,_("merging of trees%sand%sfailed"),2723oid_to_hex(&head->object.oid),2724oid_to_hex(&merge->object.oid));2725return-1;2726}27272728if(unmerged_cache()) {2729struct string_list *entries;2730struct rename_info re_info;2731int i;2732/*2733 * Only need the hashmap while processing entries, so2734 * initialize it here and free it when we are done running2735 * through the entries. Keeping it in the merge_options as2736 * opposed to decaring a local hashmap is for convenience2737 * so that we don't have to pass it to around.2738 */2739hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL,512);2740get_files_dirs(o, head);2741get_files_dirs(o, merge);27422743 entries =get_unmerged();2744 clean =handle_renames(o, common, head, merge, entries,2745&re_info);2746record_df_conflict_files(o, entries);2747if(clean <0)2748goto cleanup;2749for(i = entries->nr-1;0<= i; i--) {2750const char*path = entries->items[i].string;2751struct stage_data *e = entries->items[i].util;2752if(!e->processed) {2753int ret =process_entry(o, path, e);2754if(!ret)2755 clean =0;2756else if(ret <0) {2757 clean = ret;2758goto cleanup;2759}2760}2761}2762for(i =0; i < entries->nr; i++) {2763struct stage_data *e = entries->items[i].util;2764if(!e->processed)2765die("BUG: unprocessed path???%s",2766 entries->items[i].string);2767}27682769cleanup:2770final_cleanup_renames(&re_info);27712772string_list_clear(entries,1);2773free(entries);27742775hashmap_free(&o->current_file_dir_set,1);27762777if(clean <0)2778return clean;2779}2780else2781 clean =1;27822783if(o->call_depth && !(*result =write_tree_from_memory(o)))2784return-1;27852786return clean;2787}27882789static struct commit_list *reverse_commit_list(struct commit_list *list)2790{2791struct commit_list *next = NULL, *current, *backup;2792for(current = list; current; current = backup) {2793 backup = current->next;2794 current->next = next;2795 next = current;2796}2797return next;2798}27992800/*2801 * Merge the commits h1 and h2, return the resulting virtual2802 * commit object and a flag indicating the cleanness of the merge.2803 */2804intmerge_recursive(struct merge_options *o,2805struct commit *h1,2806struct commit *h2,2807struct commit_list *ca,2808struct commit **result)2809{2810struct commit_list *iter;2811struct commit *merged_common_ancestors;2812struct tree *mrtree;2813int clean;28142815if(show(o,4)) {2816output(o,4,_("Merging:"));2817output_commit_title(o, h1);2818output_commit_title(o, h2);2819}28202821if(!ca) {2822 ca =get_merge_bases(h1, h2);2823 ca =reverse_commit_list(ca);2824}28252826if(show(o,5)) {2827unsigned cnt =commit_list_count(ca);28282829output(o,5,Q_("found%ucommon ancestor:",2830"found%ucommon ancestors:", cnt), cnt);2831for(iter = ca; iter; iter = iter->next)2832output_commit_title(o, iter->item);2833}28342835 merged_common_ancestors =pop_commit(&ca);2836if(merged_common_ancestors == NULL) {2837/* if there is no common ancestor, use an empty tree */2838struct tree *tree;28392840 tree =lookup_tree(the_hash_algo->empty_tree);2841 merged_common_ancestors =make_virtual_commit(tree,"ancestor");2842}28432844for(iter = ca; iter; iter = iter->next) {2845const char*saved_b1, *saved_b2;2846 o->call_depth++;2847/*2848 * When the merge fails, the result contains files2849 * with conflict markers. The cleanness flag is2850 * ignored (unless indicating an error), it was never2851 * actually used, as result of merge_trees has always2852 * overwritten it: the committed "conflicts" were2853 * already resolved.2854 */2855discard_cache();2856 saved_b1 = o->branch1;2857 saved_b2 = o->branch2;2858 o->branch1 ="Temporary merge branch 1";2859 o->branch2 ="Temporary merge branch 2";2860if(merge_recursive(o, merged_common_ancestors, iter->item,2861 NULL, &merged_common_ancestors) <0)2862return-1;2863 o->branch1 = saved_b1;2864 o->branch2 = saved_b2;2865 o->call_depth--;28662867if(!merged_common_ancestors)2868returnerr(o,_("merge returned no commit"));2869}28702871discard_cache();2872if(!o->call_depth)2873read_cache();28742875 o->ancestor ="merged common ancestors";2876 clean =merge_trees(o, h1->tree, h2->tree, merged_common_ancestors->tree,2877&mrtree);2878if(clean <0) {2879flush_output(o);2880return clean;2881}28822883if(o->call_depth) {2884*result =make_virtual_commit(mrtree,"merged tree");2885commit_list_insert(h1, &(*result)->parents);2886commit_list_insert(h2, &(*result)->parents->next);2887}2888flush_output(o);2889if(!o->call_depth && o->buffer_output <2)2890strbuf_release(&o->obuf);2891if(show(o,2))2892diff_warn_rename_limit("merge.renamelimit",2893 o->needed_rename_limit,0);2894return clean;2895}28962897static struct commit *get_ref(const struct object_id *oid,const char*name)2898{2899struct object *object;29002901 object =deref_tag(parse_object(oid), name,strlen(name));2902if(!object)2903return NULL;2904if(object->type == OBJ_TREE)2905returnmake_virtual_commit((struct tree*)object, name);2906if(object->type != OBJ_COMMIT)2907return NULL;2908if(parse_commit((struct commit *)object))2909return NULL;2910return(struct commit *)object;2911}29122913intmerge_recursive_generic(struct merge_options *o,2914const struct object_id *head,2915const struct object_id *merge,2916int num_base_list,2917const struct object_id **base_list,2918struct commit **result)2919{2920int clean;2921struct lock_file lock = LOCK_INIT;2922struct commit *head_commit =get_ref(head, o->branch1);2923struct commit *next_commit =get_ref(merge, o->branch2);2924struct commit_list *ca = NULL;29252926if(base_list) {2927int i;2928for(i =0; i < num_base_list; ++i) {2929struct commit *base;2930if(!(base =get_ref(base_list[i],oid_to_hex(base_list[i]))))2931returnerr(o,_("Could not parse object '%s'"),2932oid_to_hex(base_list[i]));2933commit_list_insert(base, &ca);2934}2935}29362937hold_locked_index(&lock, LOCK_DIE_ON_ERROR);2938 clean =merge_recursive(o, head_commit, next_commit, ca,2939 result);2940if(clean <0) {2941rollback_lock_file(&lock);2942return clean;2943}29442945if(write_locked_index(&the_index, &lock,2946 COMMIT_LOCK | SKIP_IF_UNCHANGED))2947returnerr(o,_("Unable to write index."));29482949return clean ?0:1;2950}29512952static voidmerge_recursive_config(struct merge_options *o)2953{2954git_config_get_int("merge.verbosity", &o->verbosity);2955git_config_get_int("diff.renamelimit", &o->diff_rename_limit);2956git_config_get_int("merge.renamelimit", &o->merge_rename_limit);2957git_config(git_xmerge_config, NULL);2958}29592960voidinit_merge_options(struct merge_options *o)2961{2962const char*merge_verbosity;2963memset(o,0,sizeof(struct merge_options));2964 o->verbosity =2;2965 o->buffer_output =1;2966 o->diff_rename_limit = -1;2967 o->merge_rename_limit = -1;2968 o->renormalize =0;2969 o->detect_rename =1;2970merge_recursive_config(o);2971 merge_verbosity =getenv("GIT_MERGE_VERBOSITY");2972if(merge_verbosity)2973 o->verbosity =strtol(merge_verbosity, NULL,10);2974if(o->verbosity >=5)2975 o->buffer_output =0;2976strbuf_init(&o->obuf,0);2977string_list_init(&o->df_conflict_file_set,1);2978}29792980intparse_merge_opt(struct merge_options *o,const char*s)2981{2982const char*arg;29832984if(!s || !*s)2985return-1;2986if(!strcmp(s,"ours"))2987 o->recursive_variant = MERGE_RECURSIVE_OURS;2988else if(!strcmp(s,"theirs"))2989 o->recursive_variant = MERGE_RECURSIVE_THEIRS;2990else if(!strcmp(s,"subtree"))2991 o->subtree_shift ="";2992else if(skip_prefix(s,"subtree=", &arg))2993 o->subtree_shift = arg;2994else if(!strcmp(s,"patience"))2995 o->xdl_opts =DIFF_WITH_ALG(o, PATIENCE_DIFF);2996else if(!strcmp(s,"histogram"))2997 o->xdl_opts =DIFF_WITH_ALG(o, HISTOGRAM_DIFF);2998else if(skip_prefix(s,"diff-algorithm=", &arg)) {2999long value =parse_algorithm_value(arg);3000if(value <0)3001return-1;3002/* clear out previous settings */3003DIFF_XDL_CLR(o, NEED_MINIMAL);3004 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;3005 o->xdl_opts |= value;3006}3007else if(!strcmp(s,"ignore-space-change"))3008DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);3009else if(!strcmp(s,"ignore-all-space"))3010DIFF_XDL_SET(o, IGNORE_WHITESPACE);3011else if(!strcmp(s,"ignore-space-at-eol"))3012DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);3013else if(!strcmp(s,"ignore-cr-at-eol"))3014DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);3015else if(!strcmp(s,"renormalize"))3016 o->renormalize =1;3017else if(!strcmp(s,"no-renormalize"))3018 o->renormalize =0;3019else if(!strcmp(s,"no-renames"))3020 o->detect_rename =0;3021else if(!strcmp(s,"find-renames")) {3022 o->detect_rename =1;3023 o->rename_score =0;3024}3025else if(skip_prefix(s,"find-renames=", &arg) ||3026skip_prefix(s,"rename-threshold=", &arg)) {3027if((o->rename_score =parse_rename_score(&arg)) == -1|| *arg !=0)3028return-1;3029 o->detect_rename =1;3030}3031else3032return-1;3033return0;3034}