1#define NO_THE_INDEX_COMPATIBILITY_MACROS 2#include"cache.h" 3#include"dir.h" 4#include"tree.h" 5#include"tree-walk.h" 6#include"cache-tree.h" 7#include"unpack-trees.h" 8#include"progress.h" 9#include"refs.h" 10#include"attr.h" 11#include"split-index.h" 12#include"dir.h" 13#include"submodule.h" 14#include"submodule-config.h" 15 16/* 17 * Error messages expected by scripts out of plumbing commands such as 18 * read-tree. Non-scripted Porcelain is not required to use these messages 19 * and in fact are encouraged to reword them to better suit their particular 20 * situation better. See how "git checkout" and "git merge" replaces 21 * them using setup_unpack_trees_porcelain(), for example. 22 */ 23static const char*unpack_plumbing_errors[NB_UNPACK_TREES_ERROR_TYPES] = { 24/* ERROR_WOULD_OVERWRITE */ 25"Entry '%s' would be overwritten by merge. Cannot merge.", 26 27/* ERROR_NOT_UPTODATE_FILE */ 28"Entry '%s' not uptodate. Cannot merge.", 29 30/* ERROR_NOT_UPTODATE_DIR */ 31"Updating '%s' would lose untracked files in it", 32 33/* ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN */ 34"Untracked working tree file '%s' would be overwritten by merge.", 35 36/* ERROR_WOULD_LOSE_UNTRACKED_REMOVED */ 37"Untracked working tree file '%s' would be removed by merge.", 38 39/* ERROR_BIND_OVERLAP */ 40"Entry '%s' overlaps with '%s'. Cannot bind.", 41 42/* ERROR_SPARSE_NOT_UPTODATE_FILE */ 43"Entry '%s' not uptodate. Cannot update sparse checkout.", 44 45/* ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN */ 46"Working tree file '%s' would be overwritten by sparse checkout update.", 47 48/* ERROR_WOULD_LOSE_ORPHANED_REMOVED */ 49"Working tree file '%s' would be removed by sparse checkout update.", 50 51/* ERROR_WOULD_LOSE_SUBMODULE */ 52"Submodule '%s' cannot checkout new HEAD.", 53}; 54 55#define ERRORMSG(o,type) \ 56 ( ((o) && (o)->msgs[(type)]) \ 57 ? ((o)->msgs[(type)]) \ 58 : (unpack_plumbing_errors[(type)]) ) 59 60static const char*super_prefixed(const char*path) 61{ 62/* 63 * It is necessary and sufficient to have two static buffers 64 * here, as the return value of this function is fed to 65 * error() using the unpack_*_errors[] templates we see above. 66 */ 67static struct strbuf buf[2] = {STRBUF_INIT, STRBUF_INIT}; 68static int super_prefix_len = -1; 69static unsigned idx =ARRAY_SIZE(buf) -1; 70 71if(super_prefix_len <0) { 72const char*super_prefix =get_super_prefix(); 73if(!super_prefix) { 74 super_prefix_len =0; 75}else{ 76int i; 77for(i =0; i <ARRAY_SIZE(buf); i++) 78strbuf_addstr(&buf[i], super_prefix); 79 super_prefix_len = buf[0].len; 80} 81} 82 83if(!super_prefix_len) 84return path; 85 86if(++idx >=ARRAY_SIZE(buf)) 87 idx =0; 88 89strbuf_setlen(&buf[idx], super_prefix_len); 90strbuf_addstr(&buf[idx], path); 91 92return buf[idx].buf; 93} 94 95voidsetup_unpack_trees_porcelain(struct unpack_trees_options *opts, 96const char*cmd) 97{ 98int i; 99const char**msgs = opts->msgs; 100const char*msg; 101 102if(!strcmp(cmd,"checkout")) 103 msg = advice_commit_before_merge 104?_("Your local changes to the following files would be overwritten by checkout:\n%%s" 105"Please commit your changes or stash them before you switch branches.") 106:_("Your local changes to the following files would be overwritten by checkout:\n%%s"); 107else if(!strcmp(cmd,"merge")) 108 msg = advice_commit_before_merge 109?_("Your local changes to the following files would be overwritten by merge:\n%%s" 110"Please commit your changes or stash them before you merge.") 111:_("Your local changes to the following files would be overwritten by merge:\n%%s"); 112else 113 msg = advice_commit_before_merge 114?_("Your local changes to the following files would be overwritten by%s:\n%%s" 115"Please commit your changes or stash them before you%s.") 116:_("Your local changes to the following files would be overwritten by%s:\n%%s"); 117 msgs[ERROR_WOULD_OVERWRITE] = msgs[ERROR_NOT_UPTODATE_FILE] = 118xstrfmt(msg, cmd, cmd); 119 120 msgs[ERROR_NOT_UPTODATE_DIR] = 121_("Updating the following directories would lose untracked files in them:\n%s"); 122 123if(!strcmp(cmd,"checkout")) 124 msg = advice_commit_before_merge 125?_("The following untracked working tree files would be removed by checkout:\n%%s" 126"Please move or remove them before you switch branches.") 127:_("The following untracked working tree files would be removed by checkout:\n%%s"); 128else if(!strcmp(cmd,"merge")) 129 msg = advice_commit_before_merge 130?_("The following untracked working tree files would be removed by merge:\n%%s" 131"Please move or remove them before you merge.") 132:_("The following untracked working tree files would be removed by merge:\n%%s"); 133else 134 msg = advice_commit_before_merge 135?_("The following untracked working tree files would be removed by%s:\n%%s" 136"Please move or remove them before you%s.") 137:_("The following untracked working tree files would be removed by%s:\n%%s"); 138 msgs[ERROR_WOULD_LOSE_UNTRACKED_REMOVED] =xstrfmt(msg, cmd, cmd); 139 140if(!strcmp(cmd,"checkout")) 141 msg = advice_commit_before_merge 142?_("The following untracked working tree files would be overwritten by checkout:\n%%s" 143"Please move or remove them before you switch branches.") 144:_("The following untracked working tree files would be overwritten by checkout:\n%%s"); 145else if(!strcmp(cmd,"merge")) 146 msg = advice_commit_before_merge 147?_("The following untracked working tree files would be overwritten by merge:\n%%s" 148"Please move or remove them before you merge.") 149:_("The following untracked working tree files would be overwritten by merge:\n%%s"); 150else 151 msg = advice_commit_before_merge 152?_("The following untracked working tree files would be overwritten by%s:\n%%s" 153"Please move or remove them before you%s.") 154:_("The following untracked working tree files would be overwritten by%s:\n%%s"); 155 msgs[ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN] =xstrfmt(msg, cmd, cmd); 156 157/* 158 * Special case: ERROR_BIND_OVERLAP refers to a pair of paths, we 159 * cannot easily display it as a list. 160 */ 161 msgs[ERROR_BIND_OVERLAP] =_("Entry '%s' overlaps with '%s'. Cannot bind."); 162 163 msgs[ERROR_SPARSE_NOT_UPTODATE_FILE] = 164_("Cannot update sparse checkout: the following entries are not up-to-date:\n%s"); 165 msgs[ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN] = 166_("The following working tree files would be overwritten by sparse checkout update:\n%s"); 167 msgs[ERROR_WOULD_LOSE_ORPHANED_REMOVED] = 168_("The following working tree files would be removed by sparse checkout update:\n%s"); 169 msgs[ERROR_WOULD_LOSE_SUBMODULE] = 170_("Cannot update submodule:\n%s"); 171 172 opts->show_all_errors =1; 173/* rejected paths may not have a static buffer */ 174for(i =0; i <ARRAY_SIZE(opts->unpack_rejects); i++) 175 opts->unpack_rejects[i].strdup_strings =1; 176} 177 178static intdo_add_entry(struct unpack_trees_options *o,struct cache_entry *ce, 179unsigned int set,unsigned int clear) 180{ 181 clear |= CE_HASHED; 182 183if(set & CE_REMOVE) 184 set |= CE_WT_REMOVE; 185 186 ce->ce_flags = (ce->ce_flags & ~clear) | set; 187returnadd_index_entry(&o->result, ce, 188 ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE); 189} 190 191static struct cache_entry *dup_entry(const struct cache_entry *ce) 192{ 193unsigned int size =ce_size(ce); 194struct cache_entry *new=xmalloc(size); 195 196memcpy(new, ce, size); 197return new; 198} 199 200static voidadd_entry(struct unpack_trees_options *o, 201const struct cache_entry *ce, 202unsigned int set,unsigned int clear) 203{ 204do_add_entry(o,dup_entry(ce), set, clear); 205} 206 207/* 208 * add error messages on path <path> 209 * corresponding to the type <e> with the message <msg> 210 * indicating if it should be display in porcelain or not 211 */ 212static intadd_rejected_path(struct unpack_trees_options *o, 213enum unpack_trees_error_types e, 214const char*path) 215{ 216if(!o->show_all_errors) 217returnerror(ERRORMSG(o, e),super_prefixed(path)); 218 219/* 220 * Otherwise, insert in a list for future display by 221 * display_error_msgs() 222 */ 223string_list_append(&o->unpack_rejects[e], path); 224return-1; 225} 226 227/* 228 * display all the error messages stored in a nice way 229 */ 230static voiddisplay_error_msgs(struct unpack_trees_options *o) 231{ 232int e, i; 233int something_displayed =0; 234for(e =0; e < NB_UNPACK_TREES_ERROR_TYPES; e++) { 235struct string_list *rejects = &o->unpack_rejects[e]; 236if(rejects->nr >0) { 237struct strbuf path = STRBUF_INIT; 238 something_displayed =1; 239for(i =0; i < rejects->nr; i++) 240strbuf_addf(&path,"\t%s\n", rejects->items[i].string); 241error(ERRORMSG(o, e),super_prefixed(path.buf)); 242strbuf_release(&path); 243} 244string_list_clear(rejects,0); 245} 246if(something_displayed) 247fprintf(stderr,_("Aborting\n")); 248} 249 250static intcheck_submodule_move_head(const struct cache_entry *ce, 251const char*old_id, 252const char*new_id, 253struct unpack_trees_options *o) 254{ 255const struct submodule *sub =submodule_from_ce(ce); 256if(!sub) 257return0; 258 259switch(sub->update_strategy.type) { 260case SM_UPDATE_UNSPECIFIED: 261case SM_UPDATE_CHECKOUT: 262if(submodule_move_head(ce->name, old_id, new_id, SUBMODULE_MOVE_HEAD_DRY_RUN)) 263return o->gently ? -1: 264add_rejected_path(o, ERROR_WOULD_LOSE_SUBMODULE, ce->name); 265return0; 266case SM_UPDATE_NONE: 267return0; 268case SM_UPDATE_REBASE: 269case SM_UPDATE_MERGE: 270case SM_UPDATE_COMMAND: 271default: 272warning(_("submodule update strategy not supported for submodule '%s'"), ce->name); 273return-1; 274} 275} 276 277static voidreload_gitmodules_file(struct index_state *index, 278struct checkout *state) 279{ 280int i; 281for(i =0; i < index->cache_nr; i++) { 282struct cache_entry *ce = index->cache[i]; 283if(ce->ce_flags & CE_UPDATE) { 284int r =strcmp(ce->name,".gitmodules"); 285if(r <0) 286continue; 287else if(r ==0) { 288submodule_free(); 289checkout_entry(ce, state, NULL); 290gitmodules_config(); 291git_config(submodule_config, NULL); 292}else 293break; 294} 295} 296} 297 298/* 299 * Unlink the last component and schedule the leading directories for 300 * removal, such that empty directories get removed. 301 */ 302static voidunlink_entry(const struct cache_entry *ce) 303{ 304const struct submodule *sub =submodule_from_ce(ce); 305if(sub) { 306switch(sub->update_strategy.type) { 307case SM_UPDATE_UNSPECIFIED: 308case SM_UPDATE_CHECKOUT: 309case SM_UPDATE_REBASE: 310case SM_UPDATE_MERGE: 311submodule_move_head(ce->name,"HEAD", NULL, 312 SUBMODULE_MOVE_HEAD_FORCE); 313break; 314case SM_UPDATE_NONE: 315case SM_UPDATE_COMMAND: 316return;/* Do not touch the submodule. */ 317} 318} 319if(!check_leading_path(ce->name,ce_namelen(ce))) 320return; 321if(remove_or_warn(ce->ce_mode, ce->name)) 322return; 323schedule_dir_for_removal(ce->name,ce_namelen(ce)); 324} 325 326static struct progress *get_progress(struct unpack_trees_options *o) 327{ 328unsigned cnt =0, total =0; 329struct index_state *index = &o->result; 330 331if(!o->update || !o->verbose_update) 332return NULL; 333 334for(; cnt < index->cache_nr; cnt++) { 335const struct cache_entry *ce = index->cache[cnt]; 336if(ce->ce_flags & (CE_UPDATE | CE_WT_REMOVE)) 337 total++; 338} 339 340returnstart_progress_delay(_("Checking out files"), 341 total,50,1); 342} 343 344static intcheck_updates(struct unpack_trees_options *o) 345{ 346unsigned cnt =0; 347int errs =0; 348struct progress *progress = NULL; 349struct index_state *index = &o->result; 350struct checkout state = CHECKOUT_INIT; 351int i; 352 353 state.force =1; 354 state.quiet =1; 355 state.refresh_cache =1; 356 state.istate = index; 357 358 progress =get_progress(o); 359 360if(o->update) 361git_attr_set_direction(GIT_ATTR_CHECKOUT, index); 362for(i =0; i < index->cache_nr; i++) { 363const struct cache_entry *ce = index->cache[i]; 364 365if(ce->ce_flags & CE_WT_REMOVE) { 366display_progress(progress, ++cnt); 367if(o->update && !o->dry_run) 368unlink_entry(ce); 369} 370} 371remove_marked_cache_entries(index); 372remove_scheduled_dirs(); 373 374if(should_update_submodules() && o->update && !o->dry_run) 375reload_gitmodules_file(index, &state); 376 377for(i =0; i < index->cache_nr; i++) { 378struct cache_entry *ce = index->cache[i]; 379 380if(ce->ce_flags & CE_UPDATE) { 381if(ce->ce_flags & CE_WT_REMOVE) 382die("BUG: both update and delete flags are set on%s", 383 ce->name); 384display_progress(progress, ++cnt); 385 ce->ce_flags &= ~CE_UPDATE; 386if(o->update && !o->dry_run) { 387 errs |=checkout_entry(ce, &state, NULL); 388} 389} 390} 391stop_progress(&progress); 392if(o->update) 393git_attr_set_direction(GIT_ATTR_CHECKIN, NULL); 394return errs !=0; 395} 396 397static intverify_uptodate_sparse(const struct cache_entry *ce, 398struct unpack_trees_options *o); 399static intverify_absent_sparse(const struct cache_entry *ce, 400enum unpack_trees_error_types, 401struct unpack_trees_options *o); 402 403static intapply_sparse_checkout(struct index_state *istate, 404struct cache_entry *ce, 405struct unpack_trees_options *o) 406{ 407int was_skip_worktree =ce_skip_worktree(ce); 408 409if(ce->ce_flags & CE_NEW_SKIP_WORKTREE) 410 ce->ce_flags |= CE_SKIP_WORKTREE; 411else 412 ce->ce_flags &= ~CE_SKIP_WORKTREE; 413if(was_skip_worktree !=ce_skip_worktree(ce)) { 414 ce->ce_flags |= CE_UPDATE_IN_BASE; 415 istate->cache_changed |= CE_ENTRY_CHANGED; 416} 417 418/* 419 * if (!was_skip_worktree && !ce_skip_worktree()) { 420 * This is perfectly normal. Move on; 421 * } 422 */ 423 424/* 425 * Merge strategies may set CE_UPDATE|CE_REMOVE outside checkout 426 * area as a result of ce_skip_worktree() shortcuts in 427 * verify_absent() and verify_uptodate(). 428 * Make sure they don't modify worktree if they are already 429 * outside checkout area 430 */ 431if(was_skip_worktree &&ce_skip_worktree(ce)) { 432 ce->ce_flags &= ~CE_UPDATE; 433 434/* 435 * By default, when CE_REMOVE is on, CE_WT_REMOVE is also 436 * on to get that file removed from both index and worktree. 437 * If that file is already outside worktree area, don't 438 * bother remove it. 439 */ 440if(ce->ce_flags & CE_REMOVE) 441 ce->ce_flags &= ~CE_WT_REMOVE; 442} 443 444if(!was_skip_worktree &&ce_skip_worktree(ce)) { 445/* 446 * If CE_UPDATE is set, verify_uptodate() must be called already 447 * also stat info may have lost after merged_entry() so calling 448 * verify_uptodate() again may fail 449 */ 450if(!(ce->ce_flags & CE_UPDATE) &&verify_uptodate_sparse(ce, o)) 451return-1; 452 ce->ce_flags |= CE_WT_REMOVE; 453 ce->ce_flags &= ~CE_UPDATE; 454} 455if(was_skip_worktree && !ce_skip_worktree(ce)) { 456if(verify_absent_sparse(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) 457return-1; 458 ce->ce_flags |= CE_UPDATE; 459} 460return0; 461} 462 463staticinlineintcall_unpack_fn(const struct cache_entry *const*src, 464struct unpack_trees_options *o) 465{ 466int ret = o->fn(src, o); 467if(ret >0) 468 ret =0; 469return ret; 470} 471 472static voidmark_ce_used(struct cache_entry *ce,struct unpack_trees_options *o) 473{ 474 ce->ce_flags |= CE_UNPACKED; 475 476if(o->cache_bottom < o->src_index->cache_nr && 477 o->src_index->cache[o->cache_bottom] == ce) { 478int bottom = o->cache_bottom; 479while(bottom < o->src_index->cache_nr && 480 o->src_index->cache[bottom]->ce_flags & CE_UNPACKED) 481 bottom++; 482 o->cache_bottom = bottom; 483} 484} 485 486static voidmark_all_ce_unused(struct index_state *index) 487{ 488int i; 489for(i =0; i < index->cache_nr; i++) 490 index->cache[i]->ce_flags &= ~(CE_UNPACKED | CE_ADDED | CE_NEW_SKIP_WORKTREE); 491} 492 493static intlocate_in_src_index(const struct cache_entry *ce, 494struct unpack_trees_options *o) 495{ 496struct index_state *index = o->src_index; 497int len =ce_namelen(ce); 498int pos =index_name_pos(index, ce->name, len); 499if(pos <0) 500 pos = -1- pos; 501return pos; 502} 503 504/* 505 * We call unpack_index_entry() with an unmerged cache entry 506 * only in diff-index, and it wants a single callback. Skip 507 * the other unmerged entry with the same name. 508 */ 509static voidmark_ce_used_same_name(struct cache_entry *ce, 510struct unpack_trees_options *o) 511{ 512struct index_state *index = o->src_index; 513int len =ce_namelen(ce); 514int pos; 515 516for(pos =locate_in_src_index(ce, o); pos < index->cache_nr; pos++) { 517struct cache_entry *next = index->cache[pos]; 518if(len !=ce_namelen(next) || 519memcmp(ce->name, next->name, len)) 520break; 521mark_ce_used(next, o); 522} 523} 524 525static struct cache_entry *next_cache_entry(struct unpack_trees_options *o) 526{ 527const struct index_state *index = o->src_index; 528int pos = o->cache_bottom; 529 530while(pos < index->cache_nr) { 531struct cache_entry *ce = index->cache[pos]; 532if(!(ce->ce_flags & CE_UNPACKED)) 533return ce; 534 pos++; 535} 536return NULL; 537} 538 539static voidadd_same_unmerged(const struct cache_entry *ce, 540struct unpack_trees_options *o) 541{ 542struct index_state *index = o->src_index; 543int len =ce_namelen(ce); 544int pos =index_name_pos(index, ce->name, len); 545 546if(0<= pos) 547die("programming error in a caller of mark_ce_used_same_name"); 548for(pos = -pos -1; pos < index->cache_nr; pos++) { 549struct cache_entry *next = index->cache[pos]; 550if(len !=ce_namelen(next) || 551memcmp(ce->name, next->name, len)) 552break; 553add_entry(o, next,0,0); 554mark_ce_used(next, o); 555} 556} 557 558static intunpack_index_entry(struct cache_entry *ce, 559struct unpack_trees_options *o) 560{ 561const struct cache_entry *src[MAX_UNPACK_TREES +1] = { NULL, }; 562int ret; 563 564 src[0] = ce; 565 566mark_ce_used(ce, o); 567if(ce_stage(ce)) { 568if(o->skip_unmerged) { 569add_entry(o, ce,0,0); 570return0; 571} 572} 573 ret =call_unpack_fn(src, o); 574if(ce_stage(ce)) 575mark_ce_used_same_name(ce, o); 576return ret; 577} 578 579static intfind_cache_pos(struct traverse_info *,const struct name_entry *); 580 581static voidrestore_cache_bottom(struct traverse_info *info,int bottom) 582{ 583struct unpack_trees_options *o = info->data; 584 585if(o->diff_index_cached) 586return; 587 o->cache_bottom = bottom; 588} 589 590static intswitch_cache_bottom(struct traverse_info *info) 591{ 592struct unpack_trees_options *o = info->data; 593int ret, pos; 594 595if(o->diff_index_cached) 596return0; 597 ret = o->cache_bottom; 598 pos =find_cache_pos(info->prev, &info->name); 599 600if(pos < -1) 601 o->cache_bottom = -2- pos; 602else if(pos <0) 603 o->cache_bottom = o->src_index->cache_nr; 604return ret; 605} 606 607staticinlineintare_same_oid(struct name_entry *name_j,struct name_entry *name_k) 608{ 609return name_j->oid && name_k->oid && !oidcmp(name_j->oid, name_k->oid); 610} 611 612static inttraverse_trees_recursive(int n,unsigned long dirmask, 613unsigned long df_conflicts, 614struct name_entry *names, 615struct traverse_info *info) 616{ 617int i, ret, bottom; 618int nr_buf =0; 619struct tree_desc t[MAX_UNPACK_TREES]; 620void*buf[MAX_UNPACK_TREES]; 621struct traverse_info newinfo; 622struct name_entry *p; 623 624 p = names; 625while(!p->mode) 626 p++; 627 628 newinfo = *info; 629 newinfo.prev = info; 630 newinfo.pathspec = info->pathspec; 631 newinfo.name = *p; 632 newinfo.pathlen +=tree_entry_len(p) +1; 633 newinfo.df_conflicts |= df_conflicts; 634 635/* 636 * Fetch the tree from the ODB for each peer directory in the 637 * n commits. 638 * 639 * For 2- and 3-way traversals, we try to avoid hitting the 640 * ODB twice for the same OID. This should yield a nice speed 641 * up in checkouts and merges when the commits are similar. 642 * 643 * We don't bother doing the full O(n^2) search for larger n, 644 * because wider traversals don't happen that often and we 645 * avoid the search setup. 646 * 647 * When 2 peer OIDs are the same, we just copy the tree 648 * descriptor data. This implicitly borrows the buffer 649 * data from the earlier cell. 650 */ 651for(i =0; i < n; i++, dirmask >>=1) { 652if(i >0&&are_same_oid(&names[i], &names[i -1])) 653 t[i] = t[i -1]; 654else if(i >1&&are_same_oid(&names[i], &names[i -2])) 655 t[i] = t[i -2]; 656else{ 657const unsigned char*sha1 = NULL; 658if(dirmask &1) 659 sha1 = names[i].oid->hash; 660 buf[nr_buf++] =fill_tree_descriptor(t+i, sha1); 661} 662} 663 664 bottom =switch_cache_bottom(&newinfo); 665 ret =traverse_trees(n, t, &newinfo); 666restore_cache_bottom(&newinfo, bottom); 667 668for(i =0; i < nr_buf; i++) 669free(buf[i]); 670 671return ret; 672} 673 674/* 675 * Compare the traverse-path to the cache entry without actually 676 * having to generate the textual representation of the traverse 677 * path. 678 * 679 * NOTE! This *only* compares up to the size of the traverse path 680 * itself - the caller needs to do the final check for the cache 681 * entry having more data at the end! 682 */ 683static intdo_compare_entry_piecewise(const struct cache_entry *ce,const struct traverse_info *info,const struct name_entry *n) 684{ 685int len, pathlen, ce_len; 686const char*ce_name; 687 688if(info->prev) { 689int cmp =do_compare_entry_piecewise(ce, info->prev, 690&info->name); 691if(cmp) 692return cmp; 693} 694 pathlen = info->pathlen; 695 ce_len =ce_namelen(ce); 696 697/* If ce_len < pathlen then we must have previously hit "name == directory" entry */ 698if(ce_len < pathlen) 699return-1; 700 701 ce_len -= pathlen; 702 ce_name = ce->name + pathlen; 703 704 len =tree_entry_len(n); 705returndf_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); 706} 707 708static intdo_compare_entry(const struct cache_entry *ce, 709const struct traverse_info *info, 710const struct name_entry *n) 711{ 712int len, pathlen, ce_len; 713const char*ce_name; 714int cmp; 715 716/* 717 * If we have not precomputed the traverse path, it is quicker 718 * to avoid doing so. But if we have precomputed it, 719 * it is quicker to use the precomputed version. 720 */ 721if(!info->traverse_path) 722returndo_compare_entry_piecewise(ce, info, n); 723 724 cmp =strncmp(ce->name, info->traverse_path, info->pathlen); 725if(cmp) 726return cmp; 727 728 pathlen = info->pathlen; 729 ce_len =ce_namelen(ce); 730 731if(ce_len < pathlen) 732return-1; 733 734 ce_len -= pathlen; 735 ce_name = ce->name + pathlen; 736 737 len =tree_entry_len(n); 738returndf_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); 739} 740 741static intcompare_entry(const struct cache_entry *ce,const struct traverse_info *info,const struct name_entry *n) 742{ 743int cmp =do_compare_entry(ce, info, n); 744if(cmp) 745return cmp; 746 747/* 748 * Even if the beginning compared identically, the ce should 749 * compare as bigger than a directory leading up to it! 750 */ 751returnce_namelen(ce) >traverse_path_len(info, n); 752} 753 754static intce_in_traverse_path(const struct cache_entry *ce, 755const struct traverse_info *info) 756{ 757if(!info->prev) 758return1; 759if(do_compare_entry(ce, info->prev, &info->name)) 760return0; 761/* 762 * If ce (blob) is the same name as the path (which is a tree 763 * we will be descending into), it won't be inside it. 764 */ 765return(info->pathlen <ce_namelen(ce)); 766} 767 768static struct cache_entry *create_ce_entry(const struct traverse_info *info,const struct name_entry *n,int stage) 769{ 770int len =traverse_path_len(info, n); 771struct cache_entry *ce =xcalloc(1,cache_entry_size(len)); 772 773 ce->ce_mode =create_ce_mode(n->mode); 774 ce->ce_flags =create_ce_flags(stage); 775 ce->ce_namelen = len; 776oidcpy(&ce->oid, n->oid); 777make_traverse_path(ce->name, info, n); 778 779return ce; 780} 781 782static intunpack_nondirectories(int n,unsigned long mask, 783unsigned long dirmask, 784struct cache_entry **src, 785const struct name_entry *names, 786const struct traverse_info *info) 787{ 788int i; 789struct unpack_trees_options *o = info->data; 790unsigned long conflicts = info->df_conflicts | dirmask; 791 792/* Do we have *only* directories? Nothing to do */ 793if(mask == dirmask && !src[0]) 794return0; 795 796/* 797 * Ok, we've filled in up to any potential index entry in src[0], 798 * now do the rest. 799 */ 800for(i =0; i < n; i++) { 801int stage; 802unsigned int bit =1ul<< i; 803if(conflicts & bit) { 804 src[i + o->merge] = o->df_conflict_entry; 805continue; 806} 807if(!(mask & bit)) 808continue; 809if(!o->merge) 810 stage =0; 811else if(i +1< o->head_idx) 812 stage =1; 813else if(i +1> o->head_idx) 814 stage =3; 815else 816 stage =2; 817 src[i + o->merge] =create_ce_entry(info, names + i, stage); 818} 819 820if(o->merge) { 821int rc =call_unpack_fn((const struct cache_entry *const*)src, 822 o); 823for(i =0; i < n; i++) { 824struct cache_entry *ce = src[i + o->merge]; 825if(ce != o->df_conflict_entry) 826free(ce); 827} 828return rc; 829} 830 831for(i =0; i < n; i++) 832if(src[i] && src[i] != o->df_conflict_entry) 833if(do_add_entry(o, src[i],0,0)) 834return-1; 835 836return0; 837} 838 839static intunpack_failed(struct unpack_trees_options *o,const char*message) 840{ 841discard_index(&o->result); 842if(!o->gently && !o->exiting_early) { 843if(message) 844returnerror("%s", message); 845return-1; 846} 847return-1; 848} 849 850/* 851 * The tree traversal is looking at name p. If we have a matching entry, 852 * return it. If name p is a directory in the index, do not return 853 * anything, as we will want to match it when the traversal descends into 854 * the directory. 855 */ 856static intfind_cache_pos(struct traverse_info *info, 857const struct name_entry *p) 858{ 859int pos; 860struct unpack_trees_options *o = info->data; 861struct index_state *index = o->src_index; 862int pfxlen = info->pathlen; 863int p_len =tree_entry_len(p); 864 865for(pos = o->cache_bottom; pos < index->cache_nr; pos++) { 866const struct cache_entry *ce = index->cache[pos]; 867const char*ce_name, *ce_slash; 868int cmp, ce_len; 869 870if(ce->ce_flags & CE_UNPACKED) { 871/* 872 * cache_bottom entry is already unpacked, so 873 * we can never match it; don't check it 874 * again. 875 */ 876if(pos == o->cache_bottom) 877++o->cache_bottom; 878continue; 879} 880if(!ce_in_traverse_path(ce, info)) { 881/* 882 * Check if we can skip future cache checks 883 * (because we're already past all possible 884 * entries in the traverse path). 885 */ 886if(info->traverse_path) { 887if(strncmp(ce->name, info->traverse_path, 888 info->pathlen) >0) 889break; 890} 891continue; 892} 893 ce_name = ce->name + pfxlen; 894 ce_slash =strchr(ce_name,'/'); 895if(ce_slash) 896 ce_len = ce_slash - ce_name; 897else 898 ce_len =ce_namelen(ce) - pfxlen; 899 cmp =name_compare(p->path, p_len, ce_name, ce_len); 900/* 901 * Exact match; if we have a directory we need to 902 * delay returning it. 903 */ 904if(!cmp) 905return ce_slash ? -2- pos : pos; 906if(0< cmp) 907continue;/* keep looking */ 908/* 909 * ce_name sorts after p->path; could it be that we 910 * have files under p->path directory in the index? 911 * E.g. ce_name == "t-i", and p->path == "t"; we may 912 * have "t/a" in the index. 913 */ 914if(p_len < ce_len && !memcmp(ce_name, p->path, p_len) && 915 ce_name[p_len] <'/') 916continue;/* keep looking */ 917break; 918} 919return-1; 920} 921 922static struct cache_entry *find_cache_entry(struct traverse_info *info, 923const struct name_entry *p) 924{ 925int pos =find_cache_pos(info, p); 926struct unpack_trees_options *o = info->data; 927 928if(0<= pos) 929return o->src_index->cache[pos]; 930else 931return NULL; 932} 933 934static voiddebug_path(struct traverse_info *info) 935{ 936if(info->prev) { 937debug_path(info->prev); 938if(*info->prev->name.path) 939putchar('/'); 940} 941printf("%s", info->name.path); 942} 943 944static voiddebug_name_entry(int i,struct name_entry *n) 945{ 946printf("ent#%d %06o%s\n", i, 947 n->path ? n->mode :0, 948 n->path ? n->path :"(missing)"); 949} 950 951static voiddebug_unpack_callback(int n, 952unsigned long mask, 953unsigned long dirmask, 954struct name_entry *names, 955struct traverse_info *info) 956{ 957int i; 958printf("* unpack mask%lu, dirmask%lu, cnt%d", 959 mask, dirmask, n); 960debug_path(info); 961putchar('\n'); 962for(i =0; i < n; i++) 963debug_name_entry(i, names + i); 964} 965 966static intunpack_callback(int n,unsigned long mask,unsigned long dirmask,struct name_entry *names,struct traverse_info *info) 967{ 968struct cache_entry *src[MAX_UNPACK_TREES +1] = { NULL, }; 969struct unpack_trees_options *o = info->data; 970const struct name_entry *p = names; 971 972/* Find first entry with a real name (we could use "mask" too) */ 973while(!p->mode) 974 p++; 975 976if(o->debug_unpack) 977debug_unpack_callback(n, mask, dirmask, names, info); 978 979/* Are we supposed to look at the index too? */ 980if(o->merge) { 981while(1) { 982int cmp; 983struct cache_entry *ce; 984 985if(o->diff_index_cached) 986 ce =next_cache_entry(o); 987else 988 ce =find_cache_entry(info, p); 989 990if(!ce) 991break; 992 cmp =compare_entry(ce, info, p); 993if(cmp <0) { 994if(unpack_index_entry(ce, o) <0) 995returnunpack_failed(o, NULL); 996continue; 997} 998if(!cmp) { 999if(ce_stage(ce)) {1000/*1001 * If we skip unmerged index1002 * entries, we'll skip this1003 * entry *and* the tree1004 * entries associated with it!1005 */1006if(o->skip_unmerged) {1007add_same_unmerged(ce, o);1008return mask;1009}1010}1011 src[0] = ce;1012}1013break;1014}1015}10161017if(unpack_nondirectories(n, mask, dirmask, src, names, info) <0)1018return-1;10191020if(o->merge && src[0]) {1021if(ce_stage(src[0]))1022mark_ce_used_same_name(src[0], o);1023else1024mark_ce_used(src[0], o);1025}10261027/* Now handle any directories.. */1028if(dirmask) {1029/* special case: "diff-index --cached" looking at a tree */1030if(o->diff_index_cached &&1031 n ==1&& dirmask ==1&&S_ISDIR(names->mode)) {1032int matches;1033 matches =cache_tree_matches_traversal(o->src_index->cache_tree,1034 names, info);1035/*1036 * Everything under the name matches; skip the1037 * entire hierarchy. diff_index_cached codepath1038 * special cases D/F conflicts in such a way that1039 * it does not do any look-ahead, so this is safe.1040 */1041if(matches) {1042 o->cache_bottom += matches;1043return mask;1044}1045}10461047if(traverse_trees_recursive(n, dirmask, mask & ~dirmask,1048 names, info) <0)1049return-1;1050return mask;1051}10521053return mask;1054}10551056static intclear_ce_flags_1(struct cache_entry **cache,int nr,1057struct strbuf *prefix,1058int select_mask,int clear_mask,1059struct exclude_list *el,int defval);10601061/* Whole directory matching */1062static intclear_ce_flags_dir(struct cache_entry **cache,int nr,1063struct strbuf *prefix,1064char*basename,1065int select_mask,int clear_mask,1066struct exclude_list *el,int defval)1067{1068struct cache_entry **cache_end;1069int dtype = DT_DIR;1070int ret =is_excluded_from_list(prefix->buf, prefix->len,1071 basename, &dtype, el);1072int rc;10731074strbuf_addch(prefix,'/');10751076/* If undecided, use matching result of parent dir in defval */1077if(ret <0)1078 ret = defval;10791080for(cache_end = cache; cache_end != cache + nr; cache_end++) {1081struct cache_entry *ce = *cache_end;1082if(strncmp(ce->name, prefix->buf, prefix->len))1083break;1084}10851086/*1087 * TODO: check el, if there are no patterns that may conflict1088 * with ret (iow, we know in advance the incl/excl1089 * decision for the entire directory), clear flag here without1090 * calling clear_ce_flags_1(). That function will call1091 * the expensive is_excluded_from_list() on every entry.1092 */1093 rc =clear_ce_flags_1(cache, cache_end - cache,1094 prefix,1095 select_mask, clear_mask,1096 el, ret);1097strbuf_setlen(prefix, prefix->len -1);1098return rc;1099}11001101/*1102 * Traverse the index, find every entry that matches according to1103 * o->el. Do "ce_flags &= ~clear_mask" on those entries. Return the1104 * number of traversed entries.1105 *1106 * If select_mask is non-zero, only entries whose ce_flags has on of1107 * those bits enabled are traversed.1108 *1109 * cache : pointer to an index entry1110 * prefix_len : an offset to its path1111 *1112 * The current path ("prefix") including the trailing '/' is1113 * cache[0]->name[0..(prefix_len-1)]1114 * Top level path has prefix_len zero.1115 */1116static intclear_ce_flags_1(struct cache_entry **cache,int nr,1117struct strbuf *prefix,1118int select_mask,int clear_mask,1119struct exclude_list *el,int defval)1120{1121struct cache_entry **cache_end = cache + nr;11221123/*1124 * Process all entries that have the given prefix and meet1125 * select_mask condition1126 */1127while(cache != cache_end) {1128struct cache_entry *ce = *cache;1129const char*name, *slash;1130int len, dtype, ret;11311132if(select_mask && !(ce->ce_flags & select_mask)) {1133 cache++;1134continue;1135}11361137if(prefix->len &&strncmp(ce->name, prefix->buf, prefix->len))1138break;11391140 name = ce->name + prefix->len;1141 slash =strchr(name,'/');11421143/* If it's a directory, try whole directory match first */1144if(slash) {1145int processed;11461147 len = slash - name;1148strbuf_add(prefix, name, len);11491150 processed =clear_ce_flags_dir(cache, cache_end - cache,1151 prefix,1152 prefix->buf + prefix->len - len,1153 select_mask, clear_mask,1154 el, defval);11551156/* clear_c_f_dir eats a whole dir already? */1157if(processed) {1158 cache += processed;1159strbuf_setlen(prefix, prefix->len - len);1160continue;1161}11621163strbuf_addch(prefix,'/');1164 cache +=clear_ce_flags_1(cache, cache_end - cache,1165 prefix,1166 select_mask, clear_mask, el, defval);1167strbuf_setlen(prefix, prefix->len - len -1);1168continue;1169}11701171/* Non-directory */1172 dtype =ce_to_dtype(ce);1173 ret =is_excluded_from_list(ce->name,ce_namelen(ce),1174 name, &dtype, el);1175if(ret <0)1176 ret = defval;1177if(ret >0)1178 ce->ce_flags &= ~clear_mask;1179 cache++;1180}1181return nr - (cache_end - cache);1182}11831184static intclear_ce_flags(struct cache_entry **cache,int nr,1185int select_mask,int clear_mask,1186struct exclude_list *el)1187{1188static struct strbuf prefix = STRBUF_INIT;11891190strbuf_reset(&prefix);11911192returnclear_ce_flags_1(cache, nr,1193&prefix,1194 select_mask, clear_mask,1195 el,0);1196}11971198/*1199 * Set/Clear CE_NEW_SKIP_WORKTREE according to $GIT_DIR/info/sparse-checkout1200 */1201static voidmark_new_skip_worktree(struct exclude_list *el,1202struct index_state *the_index,1203int select_flag,int skip_wt_flag)1204{1205int i;12061207/*1208 * 1. Pretend the narrowest worktree: only unmerged entries1209 * are checked out1210 */1211for(i =0; i < the_index->cache_nr; i++) {1212struct cache_entry *ce = the_index->cache[i];12131214if(select_flag && !(ce->ce_flags & select_flag))1215continue;12161217if(!ce_stage(ce))1218 ce->ce_flags |= skip_wt_flag;1219else1220 ce->ce_flags &= ~skip_wt_flag;1221}12221223/*1224 * 2. Widen worktree according to sparse-checkout file.1225 * Matched entries will have skip_wt_flag cleared (i.e. "in")1226 */1227clear_ce_flags(the_index->cache, the_index->cache_nr,1228 select_flag, skip_wt_flag, el);1229}12301231static intverify_absent(const struct cache_entry *,1232enum unpack_trees_error_types,1233struct unpack_trees_options *);1234/*1235 * N-way merge "len" trees. Returns 0 on success, -1 on failure to manipulate the1236 * resulting index, -2 on failure to reflect the changes to the work tree.1237 *1238 * CE_ADDED, CE_UNPACKED and CE_NEW_SKIP_WORKTREE are used internally1239 */1240intunpack_trees(unsigned len,struct tree_desc *t,struct unpack_trees_options *o)1241{1242int i, ret;1243static struct cache_entry *dfc;1244struct exclude_list el;12451246if(len > MAX_UNPACK_TREES)1247die("unpack_trees takes at most%dtrees", MAX_UNPACK_TREES);12481249memset(&el,0,sizeof(el));1250if(!core_apply_sparse_checkout || !o->update)1251 o->skip_sparse_checkout =1;1252if(!o->skip_sparse_checkout) {1253char*sparse =git_pathdup("info/sparse-checkout");1254if(add_excludes_from_file_to_list(sparse,"",0, &el,0) <0)1255 o->skip_sparse_checkout =1;1256else1257 o->el = ⪙1258free(sparse);1259}12601261memset(&o->result,0,sizeof(o->result));1262 o->result.initialized =1;1263 o->result.timestamp.sec = o->src_index->timestamp.sec;1264 o->result.timestamp.nsec = o->src_index->timestamp.nsec;1265 o->result.version = o->src_index->version;1266 o->result.split_index = o->src_index->split_index;1267if(o->result.split_index)1268 o->result.split_index->refcount++;1269hashcpy(o->result.sha1, o->src_index->sha1);1270 o->merge_size = len;1271mark_all_ce_unused(o->src_index);12721273/*1274 * Sparse checkout loop #1: set NEW_SKIP_WORKTREE on existing entries1275 */1276if(!o->skip_sparse_checkout)1277mark_new_skip_worktree(o->el, o->src_index,0, CE_NEW_SKIP_WORKTREE);12781279if(!dfc)1280 dfc =xcalloc(1,cache_entry_size(0));1281 o->df_conflict_entry = dfc;12821283if(len) {1284const char*prefix = o->prefix ? o->prefix :"";1285struct traverse_info info;12861287setup_traverse_info(&info, prefix);1288 info.fn = unpack_callback;1289 info.data = o;1290 info.show_all_errors = o->show_all_errors;1291 info.pathspec = o->pathspec;12921293if(o->prefix) {1294/*1295 * Unpack existing index entries that sort before the1296 * prefix the tree is spliced into. Note that o->merge1297 * is always true in this case.1298 */1299while(1) {1300struct cache_entry *ce =next_cache_entry(o);1301if(!ce)1302break;1303if(ce_in_traverse_path(ce, &info))1304break;1305if(unpack_index_entry(ce, o) <0)1306goto return_failed;1307}1308}13091310if(traverse_trees(len, t, &info) <0)1311goto return_failed;1312}13131314/* Any left-over entries in the index? */1315if(o->merge) {1316while(1) {1317struct cache_entry *ce =next_cache_entry(o);1318if(!ce)1319break;1320if(unpack_index_entry(ce, o) <0)1321goto return_failed;1322}1323}1324mark_all_ce_unused(o->src_index);13251326if(o->trivial_merges_only && o->nontrivial_merge) {1327 ret =unpack_failed(o,"Merge requires file-level merging");1328goto done;1329}13301331if(!o->skip_sparse_checkout) {1332int empty_worktree =1;13331334/*1335 * Sparse checkout loop #2: set NEW_SKIP_WORKTREE on entries not in loop #11336 * If the will have NEW_SKIP_WORKTREE, also set CE_SKIP_WORKTREE1337 * so apply_sparse_checkout() won't attempt to remove it from worktree1338 */1339mark_new_skip_worktree(o->el, &o->result, CE_ADDED, CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);13401341 ret =0;1342for(i =0; i < o->result.cache_nr; i++) {1343struct cache_entry *ce = o->result.cache[i];13441345/*1346 * Entries marked with CE_ADDED in merged_entry() do not have1347 * verify_absent() check (the check is effectively disabled1348 * because CE_NEW_SKIP_WORKTREE is set unconditionally).1349 *1350 * Do the real check now because we have had1351 * correct CE_NEW_SKIP_WORKTREE1352 */1353if(ce->ce_flags & CE_ADDED &&1354verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) {1355if(!o->show_all_errors)1356goto return_failed;1357 ret = -1;1358}13591360if(apply_sparse_checkout(&o->result, ce, o)) {1361if(!o->show_all_errors)1362goto return_failed;1363 ret = -1;1364}1365if(!ce_skip_worktree(ce))1366 empty_worktree =0;13671368}1369if(ret <0)1370goto return_failed;1371/*1372 * Sparse checkout is meant to narrow down checkout area1373 * but it does not make sense to narrow down to empty working1374 * tree. This is usually a mistake in sparse checkout rules.1375 * Do not allow users to do that.1376 */1377if(o->result.cache_nr && empty_worktree) {1378 ret =unpack_failed(o,"Sparse checkout leaves no entry on working directory");1379goto done;1380}1381}13821383 o->src_index = NULL;1384 ret =check_updates(o) ? (-2) :0;1385if(o->dst_index) {1386if(!ret) {1387if(!o->result.cache_tree)1388 o->result.cache_tree =cache_tree();1389if(!cache_tree_fully_valid(o->result.cache_tree))1390cache_tree_update(&o->result,1391 WRITE_TREE_SILENT |1392 WRITE_TREE_REPAIR);1393}1394move_index_extensions(&o->result, o->dst_index);1395discard_index(o->dst_index);1396*o->dst_index = o->result;1397}else{1398discard_index(&o->result);1399}14001401done:1402clear_exclude_list(&el);1403return ret;14041405return_failed:1406if(o->show_all_errors)1407display_error_msgs(o);1408mark_all_ce_unused(o->src_index);1409 ret =unpack_failed(o, NULL);1410if(o->exiting_early)1411 ret =0;1412goto done;1413}14141415/* Here come the merge functions */14161417static intreject_merge(const struct cache_entry *ce,1418struct unpack_trees_options *o)1419{1420return o->gently ? -1:1421add_rejected_path(o, ERROR_WOULD_OVERWRITE, ce->name);1422}14231424static intsame(const struct cache_entry *a,const struct cache_entry *b)1425{1426if(!!a != !!b)1427return0;1428if(!a && !b)1429return1;1430if((a->ce_flags | b->ce_flags) & CE_CONFLICTED)1431return0;1432return a->ce_mode == b->ce_mode &&1433!oidcmp(&a->oid, &b->oid);1434}143514361437/*1438 * When a CE gets turned into an unmerged entry, we1439 * want it to be up-to-date1440 */1441static intverify_uptodate_1(const struct cache_entry *ce,1442struct unpack_trees_options *o,1443enum unpack_trees_error_types error_type)1444{1445struct stat st;14461447if(o->index_only)1448return0;14491450/*1451 * CE_VALID and CE_SKIP_WORKTREE cheat, we better check again1452 * if this entry is truly up-to-date because this file may be1453 * overwritten.1454 */1455if((ce->ce_flags & CE_VALID) ||ce_skip_worktree(ce))1456;/* keep checking */1457else if(o->reset ||ce_uptodate(ce))1458return0;14591460if(!lstat(ce->name, &st)) {1461int flags = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE;1462unsigned changed =ie_match_stat(o->src_index, ce, &st, flags);14631464if(submodule_from_ce(ce)) {1465int r =check_submodule_move_head(ce,1466"HEAD",oid_to_hex(&ce->oid), o);1467if(r)1468return o->gently ? -1:1469add_rejected_path(o, error_type, ce->name);1470return0;1471}14721473if(!changed)1474return0;1475/*1476 * Historic default policy was to allow submodule to be out1477 * of sync wrt the superproject index. If the submodule was1478 * not considered interesting above, we don't care here.1479 */1480if(S_ISGITLINK(ce->ce_mode))1481return0;14821483 errno =0;1484}1485if(errno == ENOENT)1486return0;1487return o->gently ? -1:1488add_rejected_path(o, error_type, ce->name);1489}14901491static intverify_uptodate(const struct cache_entry *ce,1492struct unpack_trees_options *o)1493{1494if(!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))1495return0;1496returnverify_uptodate_1(ce, o, ERROR_NOT_UPTODATE_FILE);1497}14981499static intverify_uptodate_sparse(const struct cache_entry *ce,1500struct unpack_trees_options *o)1501{1502returnverify_uptodate_1(ce, o, ERROR_SPARSE_NOT_UPTODATE_FILE);1503}15041505static voidinvalidate_ce_path(const struct cache_entry *ce,1506struct unpack_trees_options *o)1507{1508if(!ce)1509return;1510cache_tree_invalidate_path(o->src_index, ce->name);1511untracked_cache_invalidate_path(o->src_index, ce->name);1512}15131514/*1515 * Check that checking out ce->sha1 in subdir ce->name is not1516 * going to overwrite any working files.1517 *1518 * Currently, git does not checkout subprojects during a superproject1519 * checkout, so it is not going to overwrite anything.1520 */1521static intverify_clean_submodule(const char*old_sha1,1522const struct cache_entry *ce,1523enum unpack_trees_error_types error_type,1524struct unpack_trees_options *o)1525{1526if(!submodule_from_ce(ce))1527return0;15281529returncheck_submodule_move_head(ce, old_sha1,1530oid_to_hex(&ce->oid), o);1531}15321533static intverify_clean_subdirectory(const struct cache_entry *ce,1534enum unpack_trees_error_types error_type,1535struct unpack_trees_options *o)1536{1537/*1538 * we are about to extract "ce->name"; we would not want to lose1539 * anything in the existing directory there.1540 */1541int namelen;1542int i;1543struct dir_struct d;1544char*pathbuf;1545int cnt =0;15461547if(S_ISGITLINK(ce->ce_mode)) {1548unsigned char sha1[20];1549int sub_head =resolve_gitlink_ref(ce->name,"HEAD", sha1);1550/*1551 * If we are not going to update the submodule, then1552 * we don't care.1553 */1554if(!sub_head && !hashcmp(sha1, ce->oid.hash))1555return0;1556returnverify_clean_submodule(sub_head ? NULL :sha1_to_hex(sha1),1557 ce, error_type, o);1558}15591560/*1561 * First let's make sure we do not have a local modification1562 * in that directory.1563 */1564 namelen =ce_namelen(ce);1565for(i =locate_in_src_index(ce, o);1566 i < o->src_index->cache_nr;1567 i++) {1568struct cache_entry *ce2 = o->src_index->cache[i];1569int len =ce_namelen(ce2);1570if(len < namelen ||1571strncmp(ce->name, ce2->name, namelen) ||1572 ce2->name[namelen] !='/')1573break;1574/*1575 * ce2->name is an entry in the subdirectory to be1576 * removed.1577 */1578if(!ce_stage(ce2)) {1579if(verify_uptodate(ce2, o))1580return-1;1581add_entry(o, ce2, CE_REMOVE,0);1582mark_ce_used(ce2, o);1583}1584 cnt++;1585}15861587/*1588 * Then we need to make sure that we do not lose a locally1589 * present file that is not ignored.1590 */1591 pathbuf =xstrfmt("%.*s/", namelen, ce->name);15921593memset(&d,0,sizeof(d));1594if(o->dir)1595 d.exclude_per_dir = o->dir->exclude_per_dir;1596 i =read_directory(&d, pathbuf, namelen+1, NULL);1597if(i)1598return o->gently ? -1:1599add_rejected_path(o, ERROR_NOT_UPTODATE_DIR, ce->name);1600free(pathbuf);1601return cnt;1602}16031604/*1605 * This gets called when there was no index entry for the tree entry 'dst',1606 * but we found a file in the working tree that 'lstat()' said was fine,1607 * and we're on a case-insensitive filesystem.1608 *1609 * See if we can find a case-insensitive match in the index that also1610 * matches the stat information, and assume it's that other file!1611 */1612static inticase_exists(struct unpack_trees_options *o,const char*name,int len,struct stat *st)1613{1614const struct cache_entry *src;16151616 src =index_file_exists(o->src_index, name, len,1);1617return src && !ie_match_stat(o->src_index, src, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);1618}16191620static intcheck_ok_to_remove(const char*name,int len,int dtype,1621const struct cache_entry *ce,struct stat *st,1622enum unpack_trees_error_types error_type,1623struct unpack_trees_options *o)1624{1625const struct cache_entry *result;16261627/*1628 * It may be that the 'lstat()' succeeded even though1629 * target 'ce' was absent, because there is an old1630 * entry that is different only in case..1631 *1632 * Ignore that lstat() if it matches.1633 */1634if(ignore_case &&icase_exists(o, name, len, st))1635return0;16361637if(o->dir &&1638is_excluded(o->dir, name, &dtype))1639/*1640 * ce->name is explicitly excluded, so it is Ok to1641 * overwrite it.1642 */1643return0;1644if(S_ISDIR(st->st_mode)) {1645/*1646 * We are checking out path "foo" and1647 * found "foo/." in the working tree.1648 * This is tricky -- if we have modified1649 * files that are in "foo/" we would lose1650 * them.1651 */1652if(verify_clean_subdirectory(ce, error_type, o) <0)1653return-1;1654return0;1655}16561657/*1658 * The previous round may already have decided to1659 * delete this path, which is in a subdirectory that1660 * is being replaced with a blob.1661 */1662 result =index_file_exists(&o->result, name, len,0);1663if(result) {1664if(result->ce_flags & CE_REMOVE)1665return0;1666}16671668return o->gently ? -1:1669add_rejected_path(o, error_type, name);1670}16711672/*1673 * We do not want to remove or overwrite a working tree file that1674 * is not tracked, unless it is ignored.1675 */1676static intverify_absent_1(const struct cache_entry *ce,1677enum unpack_trees_error_types error_type,1678struct unpack_trees_options *o)1679{1680int len;1681struct stat st;16821683if(o->index_only || o->reset || !o->update)1684return0;16851686 len =check_leading_path(ce->name,ce_namelen(ce));1687if(!len)1688return0;1689else if(len >0) {1690char*path;1691int ret;16921693 path =xmemdupz(ce->name, len);1694if(lstat(path, &st))1695 ret =error_errno("cannot stat '%s'", path);1696else{1697if(submodule_from_ce(ce))1698 ret =check_submodule_move_head(ce,1699oid_to_hex(&ce->oid),1700 NULL, o);1701else1702 ret =check_ok_to_remove(path, len, DT_UNKNOWN, NULL,1703&st, error_type, o);1704}1705free(path);1706return ret;1707}else if(lstat(ce->name, &st)) {1708if(errno != ENOENT)1709returnerror_errno("cannot stat '%s'", ce->name);1710return0;1711}else{1712if(submodule_from_ce(ce))1713returncheck_submodule_move_head(ce,oid_to_hex(&ce->oid),1714 NULL, o);17151716returncheck_ok_to_remove(ce->name,ce_namelen(ce),1717ce_to_dtype(ce), ce, &st,1718 error_type, o);1719}1720}17211722static intverify_absent(const struct cache_entry *ce,1723enum unpack_trees_error_types error_type,1724struct unpack_trees_options *o)1725{1726if(!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))1727return0;1728returnverify_absent_1(ce, error_type, o);1729}17301731static intverify_absent_sparse(const struct cache_entry *ce,1732enum unpack_trees_error_types error_type,1733struct unpack_trees_options *o)1734{1735enum unpack_trees_error_types orphaned_error = error_type;1736if(orphaned_error == ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN)1737 orphaned_error = ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN;17381739returnverify_absent_1(ce, orphaned_error, o);1740}17411742static intmerged_entry(const struct cache_entry *ce,1743const struct cache_entry *old,1744struct unpack_trees_options *o)1745{1746int update = CE_UPDATE;1747struct cache_entry *merge =dup_entry(ce);17481749if(!old) {1750/*1751 * New index entries. In sparse checkout, the following1752 * verify_absent() will be delayed until after1753 * traverse_trees() finishes in unpack_trees(), then:1754 *1755 * - CE_NEW_SKIP_WORKTREE will be computed correctly1756 * - verify_absent() be called again, this time with1757 * correct CE_NEW_SKIP_WORKTREE1758 *1759 * verify_absent() call here does nothing in sparse1760 * checkout (i.e. o->skip_sparse_checkout == 0)1761 */1762 update |= CE_ADDED;1763 merge->ce_flags |= CE_NEW_SKIP_WORKTREE;17641765if(verify_absent(merge,1766 ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) {1767free(merge);1768return-1;1769}1770invalidate_ce_path(merge, o);17711772if(submodule_from_ce(ce)) {1773int ret =check_submodule_move_head(ce, NULL,1774oid_to_hex(&ce->oid),1775 o);1776if(ret)1777return ret;1778}17791780}else if(!(old->ce_flags & CE_CONFLICTED)) {1781/*1782 * See if we can re-use the old CE directly?1783 * That way we get the uptodate stat info.1784 *1785 * This also removes the UPDATE flag on a match; otherwise1786 * we will end up overwriting local changes in the work tree.1787 */1788if(same(old, merge)) {1789copy_cache_entry(merge, old);1790 update =0;1791}else{1792if(verify_uptodate(old, o)) {1793free(merge);1794return-1;1795}1796/* Migrate old flags over */1797 update |= old->ce_flags & (CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);1798invalidate_ce_path(old, o);1799}18001801if(submodule_from_ce(ce)) {1802int ret =check_submodule_move_head(ce,oid_to_hex(&old->oid),1803oid_to_hex(&ce->oid),1804 o);1805if(ret)1806return ret;1807}1808}else{1809/*1810 * Previously unmerged entry left as an existence1811 * marker by read_index_unmerged();1812 */1813invalidate_ce_path(old, o);1814}18151816do_add_entry(o, merge, update, CE_STAGEMASK);1817return1;1818}18191820static intdeleted_entry(const struct cache_entry *ce,1821const struct cache_entry *old,1822struct unpack_trees_options *o)1823{1824/* Did it exist in the index? */1825if(!old) {1826if(verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))1827return-1;1828return0;1829}1830if(!(old->ce_flags & CE_CONFLICTED) &&verify_uptodate(old, o))1831return-1;1832add_entry(o, ce, CE_REMOVE,0);1833invalidate_ce_path(ce, o);1834return1;1835}18361837static intkeep_entry(const struct cache_entry *ce,1838struct unpack_trees_options *o)1839{1840add_entry(o, ce,0,0);1841return1;1842}18431844#if DBRT_DEBUG1845static voidshow_stage_entry(FILE*o,1846const char*label,const struct cache_entry *ce)1847{1848if(!ce)1849fprintf(o,"%s(missing)\n", label);1850else1851fprintf(o,"%s%06o%s %d\t%s\n",1852 label,1853 ce->ce_mode,1854oid_to_hex(&ce->oid),1855ce_stage(ce),1856 ce->name);1857}1858#endif18591860intthreeway_merge(const struct cache_entry *const*stages,1861struct unpack_trees_options *o)1862{1863const struct cache_entry *index;1864const struct cache_entry *head;1865const struct cache_entry *remote = stages[o->head_idx +1];1866int count;1867int head_match =0;1868int remote_match =0;18691870int df_conflict_head =0;1871int df_conflict_remote =0;18721873int any_anc_missing =0;1874int no_anc_exists =1;1875int i;18761877for(i =1; i < o->head_idx; i++) {1878if(!stages[i] || stages[i] == o->df_conflict_entry)1879 any_anc_missing =1;1880else1881 no_anc_exists =0;1882}18831884 index = stages[0];1885 head = stages[o->head_idx];18861887if(head == o->df_conflict_entry) {1888 df_conflict_head =1;1889 head = NULL;1890}18911892if(remote == o->df_conflict_entry) {1893 df_conflict_remote =1;1894 remote = NULL;1895}18961897/*1898 * First, if there's a #16 situation, note that to prevent #131899 * and #14.1900 */1901if(!same(remote, head)) {1902for(i =1; i < o->head_idx; i++) {1903if(same(stages[i], head)) {1904 head_match = i;1905}1906if(same(stages[i], remote)) {1907 remote_match = i;1908}1909}1910}19111912/*1913 * We start with cases where the index is allowed to match1914 * something other than the head: #14(ALT) and #2ALT, where it1915 * is permitted to match the result instead.1916 */1917/* #14, #14ALT, #2ALT */1918if(remote && !df_conflict_head && head_match && !remote_match) {1919if(index && !same(index, remote) && !same(index, head))1920returnreject_merge(index, o);1921returnmerged_entry(remote, index, o);1922}1923/*1924 * If we have an entry in the index cache, then we want to1925 * make sure that it matches head.1926 */1927if(index && !same(index, head))1928returnreject_merge(index, o);19291930if(head) {1931/* #5ALT, #15 */1932if(same(head, remote))1933returnmerged_entry(head, index, o);1934/* #13, #3ALT */1935if(!df_conflict_remote && remote_match && !head_match)1936returnmerged_entry(head, index, o);1937}19381939/* #1 */1940if(!head && !remote && any_anc_missing)1941return0;19421943/*1944 * Under the "aggressive" rule, we resolve mostly trivial1945 * cases that we historically had git-merge-one-file resolve.1946 */1947if(o->aggressive) {1948int head_deleted = !head;1949int remote_deleted = !remote;1950const struct cache_entry *ce = NULL;19511952if(index)1953 ce = index;1954else if(head)1955 ce = head;1956else if(remote)1957 ce = remote;1958else{1959for(i =1; i < o->head_idx; i++) {1960if(stages[i] && stages[i] != o->df_conflict_entry) {1961 ce = stages[i];1962break;1963}1964}1965}19661967/*1968 * Deleted in both.1969 * Deleted in one and unchanged in the other.1970 */1971if((head_deleted && remote_deleted) ||1972(head_deleted && remote && remote_match) ||1973(remote_deleted && head && head_match)) {1974if(index)1975returndeleted_entry(index, index, o);1976if(ce && !head_deleted) {1977if(verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))1978return-1;1979}1980return0;1981}1982/*1983 * Added in both, identically.1984 */1985if(no_anc_exists && head && remote &&same(head, remote))1986returnmerged_entry(head, index, o);19871988}19891990/* Below are "no merge" cases, which require that the index be1991 * up-to-date to avoid the files getting overwritten with1992 * conflict resolution files.1993 */1994if(index) {1995if(verify_uptodate(index, o))1996return-1;1997}19981999 o->nontrivial_merge =1;20002001/* #2, #3, #4, #6, #7, #9, #10, #11. */2002 count =0;2003if(!head_match || !remote_match) {2004for(i =1; i < o->head_idx; i++) {2005if(stages[i] && stages[i] != o->df_conflict_entry) {2006keep_entry(stages[i], o);2007 count++;2008break;2009}2010}2011}2012#if DBRT_DEBUG2013else{2014fprintf(stderr,"read-tree: warning #16 detected\n");2015show_stage_entry(stderr,"head ", stages[head_match]);2016show_stage_entry(stderr,"remote ", stages[remote_match]);2017}2018#endif2019if(head) { count +=keep_entry(head, o); }2020if(remote) { count +=keep_entry(remote, o); }2021return count;2022}20232024/*2025 * Two-way merge.2026 *2027 * The rule is to "carry forward" what is in the index without losing2028 * information across a "fast-forward", favoring a successful merge2029 * over a merge failure when it makes sense. For details of the2030 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.2031 *2032 */2033inttwoway_merge(const struct cache_entry *const*src,2034struct unpack_trees_options *o)2035{2036const struct cache_entry *current = src[0];2037const struct cache_entry *oldtree = src[1];2038const struct cache_entry *newtree = src[2];20392040if(o->merge_size !=2)2041returnerror("Cannot do a twoway merge of%dtrees",2042 o->merge_size);20432044if(oldtree == o->df_conflict_entry)2045 oldtree = NULL;2046if(newtree == o->df_conflict_entry)2047 newtree = NULL;20482049if(current) {2050if(current->ce_flags & CE_CONFLICTED) {2051if(same(oldtree, newtree) || o->reset) {2052if(!newtree)2053returndeleted_entry(current, current, o);2054else2055returnmerged_entry(newtree, current, o);2056}2057returnreject_merge(current, o);2058}else if((!oldtree && !newtree) ||/* 4 and 5 */2059(!oldtree && newtree &&2060same(current, newtree)) ||/* 6 and 7 */2061(oldtree && newtree &&2062same(oldtree, newtree)) ||/* 14 and 15 */2063(oldtree && newtree &&2064!same(oldtree, newtree) &&/* 18 and 19 */2065same(current, newtree))) {2066returnkeep_entry(current, o);2067}else if(oldtree && !newtree &&same(current, oldtree)) {2068/* 10 or 11 */2069returndeleted_entry(oldtree, current, o);2070}else if(oldtree && newtree &&2071same(current, oldtree) && !same(current, newtree)) {2072/* 20 or 21 */2073returnmerged_entry(newtree, current, o);2074}else2075returnreject_merge(current, o);2076}2077else if(newtree) {2078if(oldtree && !o->initial_checkout) {2079/*2080 * deletion of the path was staged;2081 */2082if(same(oldtree, newtree))2083return1;2084returnreject_merge(oldtree, o);2085}2086returnmerged_entry(newtree, current, o);2087}2088returndeleted_entry(oldtree, current, o);2089}20902091/*2092 * Bind merge.2093 *2094 * Keep the index entries at stage0, collapse stage1 but make sure2095 * stage0 does not have anything there.2096 */2097intbind_merge(const struct cache_entry *const*src,2098struct unpack_trees_options *o)2099{2100const struct cache_entry *old = src[0];2101const struct cache_entry *a = src[1];21022103if(o->merge_size !=1)2104returnerror("Cannot do a bind merge of%dtrees",2105 o->merge_size);2106if(a && old)2107return o->gently ? -1:2108error(ERRORMSG(o, ERROR_BIND_OVERLAP),2109super_prefixed(a->name),2110super_prefixed(old->name));2111if(!a)2112returnkeep_entry(old, o);2113else2114returnmerged_entry(a, NULL, o);2115}21162117/*2118 * One-way merge.2119 *2120 * The rule is:2121 * - take the stat information from stage0, take the data from stage12122 */2123intoneway_merge(const struct cache_entry *const*src,2124struct unpack_trees_options *o)2125{2126const struct cache_entry *old = src[0];2127const struct cache_entry *a = src[1];21282129if(o->merge_size !=1)2130returnerror("Cannot do a oneway merge of%dtrees",2131 o->merge_size);21322133if(!a || a == o->df_conflict_entry)2134returndeleted_entry(old, old, o);21352136if(old &&same(old, a)) {2137int update =0;2138if(o->reset && o->update && !ce_uptodate(old) && !ce_skip_worktree(old)) {2139struct stat st;2140if(lstat(old->name, &st) ||2141ie_match_stat(o->src_index, old, &st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE))2142 update |= CE_UPDATE;2143}2144add_entry(o, old, update,0);2145return0;2146}2147returnmerged_entry(a, old, o);2148}