1#define USE_THE_INDEX_COMPATIBILITY_MACROS 2#include"builtin.h" 3#include"advice.h" 4#include"blob.h" 5#include"branch.h" 6#include"cache-tree.h" 7#include"checkout.h" 8#include"commit.h" 9#include"config.h" 10#include"diff.h" 11#include"dir.h" 12#include"ll-merge.h" 13#include"lockfile.h" 14#include"merge-recursive.h" 15#include"object-store.h" 16#include"parse-options.h" 17#include"refs.h" 18#include"remote.h" 19#include"resolve-undo.h" 20#include"revision.h" 21#include"run-command.h" 22#include"submodule.h" 23#include"submodule-config.h" 24#include"tree.h" 25#include"tree-walk.h" 26#include"unpack-trees.h" 27#include"wt-status.h" 28#include"xdiff-interface.h" 29 30static const char*const checkout_usage[] = { 31N_("git checkout [<options>] <branch>"), 32N_("git checkout [<options>] [<branch>] -- <file>..."), 33 NULL, 34}; 35 36static const char*const switch_branch_usage[] = { 37N_("git switch [<options>] [<branch>]"), 38 NULL, 39}; 40 41static const char*const restore_usage[] = { 42N_("git restore [<options>] [--source=<branch>] <file>..."), 43 NULL, 44}; 45 46struct checkout_opts { 47int patch_mode; 48int quiet; 49int merge; 50int force; 51int force_detach; 52int implicit_detach; 53int writeout_stage; 54int overwrite_ignore; 55int ignore_skipworktree; 56int ignore_other_worktrees; 57int show_progress; 58int count_checkout_paths; 59int overlay_mode; 60int dwim_new_local_branch; 61int discard_changes; 62int accept_ref; 63int accept_pathspec; 64int switch_branch_doing_nothing_is_ok; 65int only_merge_on_switching_branches; 66int can_switch_when_in_progress; 67int orphan_from_empty_tree; 68int empty_pathspec_ok; 69int checkout_index; 70int checkout_worktree; 71const char*ignore_unmerged_opt; 72int ignore_unmerged; 73 74const char*new_branch; 75const char*new_branch_force; 76const char*new_orphan_branch; 77int new_branch_log; 78enum branch_track track; 79struct diff_options diff_options; 80char*conflict_style; 81 82int branch_exists; 83const char*prefix; 84struct pathspec pathspec; 85const char*from_treeish; 86struct tree *source_tree; 87}; 88 89static intpost_checkout_hook(struct commit *old_commit,struct commit *new_commit, 90int changed) 91{ 92returnrun_hook_le(NULL,"post-checkout", 93oid_to_hex(old_commit ? &old_commit->object.oid : &null_oid), 94oid_to_hex(new_commit ? &new_commit->object.oid : &null_oid), 95 changed ?"1":"0", NULL); 96/* "new_commit" can be NULL when checking out from the index before 97 a commit exists. */ 98 99} 100 101static intupdate_some(const struct object_id *oid,struct strbuf *base, 102const char*pathname,unsigned mode,int stage,void*context) 103{ 104int len; 105struct cache_entry *ce; 106int pos; 107 108if(S_ISDIR(mode)) 109return READ_TREE_RECURSIVE; 110 111 len = base->len +strlen(pathname); 112 ce =make_empty_cache_entry(&the_index, len); 113oidcpy(&ce->oid, oid); 114memcpy(ce->name, base->buf, base->len); 115memcpy(ce->name + base->len, pathname, len - base->len); 116 ce->ce_flags =create_ce_flags(0) | CE_UPDATE; 117 ce->ce_namelen = len; 118 ce->ce_mode =create_ce_mode(mode); 119 120/* 121 * If the entry is the same as the current index, we can leave the old 122 * entry in place. Whether it is UPTODATE or not, checkout_entry will 123 * do the right thing. 124 */ 125 pos =cache_name_pos(ce->name, ce->ce_namelen); 126if(pos >=0) { 127struct cache_entry *old = active_cache[pos]; 128if(ce->ce_mode == old->ce_mode && 129!ce_intent_to_add(old) && 130oideq(&ce->oid, &old->oid)) { 131 old->ce_flags |= CE_UPDATE; 132discard_cache_entry(ce); 133return0; 134} 135} 136 137add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE); 138return0; 139} 140 141static intread_tree_some(struct tree *tree,const struct pathspec *pathspec) 142{ 143read_tree_recursive(the_repository, tree,"",0,0, 144 pathspec, update_some, NULL); 145 146/* update the index with the given tree's info 147 * for all args, expanding wildcards, and exit 148 * with any non-zero return code. 149 */ 150return0; 151} 152 153static intskip_same_name(const struct cache_entry *ce,int pos) 154{ 155while(++pos < active_nr && 156!strcmp(active_cache[pos]->name, ce->name)) 157;/* skip */ 158return pos; 159} 160 161static intcheck_stage(int stage,const struct cache_entry *ce,int pos, 162int overlay_mode) 163{ 164while(pos < active_nr && 165!strcmp(active_cache[pos]->name, ce->name)) { 166if(ce_stage(active_cache[pos]) == stage) 167return0; 168 pos++; 169} 170if(!overlay_mode) 171return0; 172if(stage ==2) 173returnerror(_("path '%s' does not have our version"), ce->name); 174else 175returnerror(_("path '%s' does not have their version"), ce->name); 176} 177 178static intcheck_stages(unsigned stages,const struct cache_entry *ce,int pos) 179{ 180unsigned seen =0; 181const char*name = ce->name; 182 183while(pos < active_nr) { 184 ce = active_cache[pos]; 185if(strcmp(name, ce->name)) 186break; 187 seen |= (1<<ce_stage(ce)); 188 pos++; 189} 190if((stages & seen) != stages) 191returnerror(_("path '%s' does not have all necessary versions"), 192 name); 193return0; 194} 195 196static intcheckout_stage(int stage,const struct cache_entry *ce,int pos, 197const struct checkout *state,int*nr_checkouts, 198int overlay_mode) 199{ 200while(pos < active_nr && 201!strcmp(active_cache[pos]->name, ce->name)) { 202if(ce_stage(active_cache[pos]) == stage) 203returncheckout_entry(active_cache[pos], state, 204 NULL, nr_checkouts); 205 pos++; 206} 207if(!overlay_mode) { 208unlink_entry(ce); 209return0; 210} 211if(stage ==2) 212returnerror(_("path '%s' does not have our version"), ce->name); 213else 214returnerror(_("path '%s' does not have their version"), ce->name); 215} 216 217static intcheckout_merged(int pos,const struct checkout *state,int*nr_checkouts) 218{ 219struct cache_entry *ce = active_cache[pos]; 220const char*path = ce->name; 221 mmfile_t ancestor, ours, theirs; 222int status; 223struct object_id oid; 224 mmbuffer_t result_buf; 225struct object_id threeway[3]; 226unsigned mode =0; 227 228memset(threeway,0,sizeof(threeway)); 229while(pos < active_nr) { 230int stage; 231 stage =ce_stage(ce); 232if(!stage ||strcmp(path, ce->name)) 233break; 234oidcpy(&threeway[stage -1], &ce->oid); 235if(stage ==2) 236 mode =create_ce_mode(ce->ce_mode); 237 pos++; 238 ce = active_cache[pos]; 239} 240if(is_null_oid(&threeway[1]) ||is_null_oid(&threeway[2])) 241returnerror(_("path '%s' does not have necessary versions"), path); 242 243read_mmblob(&ancestor, &threeway[0]); 244read_mmblob(&ours, &threeway[1]); 245read_mmblob(&theirs, &threeway[2]); 246 247/* 248 * NEEDSWORK: re-create conflicts from merges with 249 * merge.renormalize set, too 250 */ 251 status =ll_merge(&result_buf, path, &ancestor,"base", 252&ours,"ours", &theirs,"theirs", 253 state->istate, NULL); 254free(ancestor.ptr); 255free(ours.ptr); 256free(theirs.ptr); 257if(status <0|| !result_buf.ptr) { 258free(result_buf.ptr); 259returnerror(_("path '%s': cannot merge"), path); 260} 261 262/* 263 * NEEDSWORK: 264 * There is absolutely no reason to write this as a blob object 265 * and create a phony cache entry. This hack is primarily to get 266 * to the write_entry() machinery that massages the contents to 267 * work-tree format and writes out which only allows it for a 268 * cache entry. The code in write_entry() needs to be refactored 269 * to allow us to feed a <buffer, size, mode> instead of a cache 270 * entry. Such a refactoring would help merge_recursive as well 271 * (it also writes the merge result to the object database even 272 * when it may contain conflicts). 273 */ 274if(write_object_file(result_buf.ptr, result_buf.size, blob_type, &oid)) 275die(_("Unable to add merge result for '%s'"), path); 276free(result_buf.ptr); 277 ce =make_transient_cache_entry(mode, &oid, path,2); 278if(!ce) 279die(_("make_cache_entry failed for path '%s'"), path); 280 status =checkout_entry(ce, state, NULL, nr_checkouts); 281discard_cache_entry(ce); 282return status; 283} 284 285static voidmark_ce_for_checkout_overlay(struct cache_entry *ce, 286char*ps_matched, 287const struct checkout_opts *opts) 288{ 289 ce->ce_flags &= ~CE_MATCHED; 290if(!opts->ignore_skipworktree &&ce_skip_worktree(ce)) 291return; 292if(opts->source_tree && !(ce->ce_flags & CE_UPDATE)) 293/* 294 * "git checkout tree-ish -- path", but this entry 295 * is in the original index but is not in tree-ish 296 * or does not match the pathspec; it will not be 297 * checked out to the working tree. We will not do 298 * anything to this entry at all. 299 */ 300return; 301/* 302 * Either this entry came from the tree-ish we are 303 * checking the paths out of, or we are checking out 304 * of the index. 305 * 306 * If it comes from the tree-ish, we already know it 307 * matches the pathspec and could just stamp 308 * CE_MATCHED to it from update_some(). But we still 309 * need ps_matched and read_tree_recursive (and 310 * eventually tree_entry_interesting) cannot fill 311 * ps_matched yet. Once it can, we can avoid calling 312 * match_pathspec() for _all_ entries when 313 * opts->source_tree != NULL. 314 */ 315if(ce_path_match(&the_index, ce, &opts->pathspec, ps_matched)) 316 ce->ce_flags |= CE_MATCHED; 317} 318 319static voidmark_ce_for_checkout_no_overlay(struct cache_entry *ce, 320char*ps_matched, 321const struct checkout_opts *opts) 322{ 323 ce->ce_flags &= ~CE_MATCHED; 324if(!opts->ignore_skipworktree &&ce_skip_worktree(ce)) 325return; 326if(ce_path_match(&the_index, ce, &opts->pathspec, ps_matched)) { 327 ce->ce_flags |= CE_MATCHED; 328if(opts->source_tree && !(ce->ce_flags & CE_UPDATE)) 329/* 330 * In overlay mode, but the path is not in 331 * tree-ish, which means we should remove it 332 * from the index and the working tree. 333 */ 334 ce->ce_flags |= CE_REMOVE | CE_WT_REMOVE; 335} 336} 337 338static intcheckout_worktree(const struct checkout_opts *opts) 339{ 340struct checkout state = CHECKOUT_INIT; 341int nr_checkouts =0, nr_unmerged =0; 342int errs =0; 343int pos; 344 345 state.force =1; 346 state.refresh_cache =1; 347 state.istate = &the_index; 348 349enable_delayed_checkout(&state); 350for(pos =0; pos < active_nr; pos++) { 351struct cache_entry *ce = active_cache[pos]; 352if(ce->ce_flags & CE_MATCHED) { 353if(!ce_stage(ce)) { 354 errs |=checkout_entry(ce, &state, 355 NULL, &nr_checkouts); 356continue; 357} 358if(opts->writeout_stage) 359 errs |=checkout_stage(opts->writeout_stage, 360 ce, pos, 361&state, 362&nr_checkouts, opts->overlay_mode); 363else if(opts->merge) 364 errs |=checkout_merged(pos, &state, 365&nr_unmerged); 366 pos =skip_same_name(ce, pos) -1; 367} 368} 369remove_marked_cache_entries(&the_index,1); 370remove_scheduled_dirs(); 371 errs |=finish_delayed_checkout(&state, &nr_checkouts); 372 373if(opts->count_checkout_paths) { 374if(nr_unmerged) 375fprintf_ln(stderr,Q_("Recreated%dmerge conflict", 376"Recreated%dmerge conflicts", 377 nr_unmerged), 378 nr_unmerged); 379if(opts->source_tree) 380fprintf_ln(stderr,Q_("Updated%dpath from%s", 381"Updated%dpaths from%s", 382 nr_checkouts), 383 nr_checkouts, 384find_unique_abbrev(&opts->source_tree->object.oid, 385 DEFAULT_ABBREV)); 386else if(!nr_unmerged || nr_checkouts) 387fprintf_ln(stderr,Q_("Updated%dpath from the index", 388"Updated%dpaths from the index", 389 nr_checkouts), 390 nr_checkouts); 391} 392 393return errs; 394} 395 396static intcheckout_paths(const struct checkout_opts *opts, 397const char*revision) 398{ 399int pos; 400static char*ps_matched; 401struct object_id rev; 402struct commit *head; 403int errs =0; 404struct lock_file lock_file = LOCK_INIT; 405int checkout_index; 406 407trace2_cmd_mode(opts->patch_mode ?"patch":"path"); 408 409if(opts->track != BRANCH_TRACK_UNSPECIFIED) 410die(_("'%s' cannot be used with updating paths"),"--track"); 411 412if(opts->new_branch_log) 413die(_("'%s' cannot be used with updating paths"),"-l"); 414 415if(opts->ignore_unmerged && opts->patch_mode) 416die(_("'%s' cannot be used with updating paths"), 417 opts->ignore_unmerged_opt); 418 419if(opts->force_detach) 420die(_("'%s' cannot be used with updating paths"),"--detach"); 421 422if(opts->merge && opts->patch_mode) 423die(_("'%s' cannot be used with%s"),"--merge","--patch"); 424 425if(opts->ignore_unmerged && opts->merge) 426die(_("'%s' cannot be used with%s"), 427 opts->ignore_unmerged_opt,"-m"); 428 429if(opts->new_branch) 430die(_("Cannot update paths and switch to branch '%s' at the same time."), 431 opts->new_branch); 432 433if(!opts->checkout_worktree && !opts->checkout_index) 434die(_("neither '%s' or '%s' is specified"), 435"--staged","--worktree"); 436 437if(!opts->checkout_worktree && !opts->from_treeish) 438die(_("'%s' must be used when '%s' is not specified"), 439"--worktree","--source"); 440 441if(opts->checkout_index && !opts->checkout_worktree && 442 opts->writeout_stage) 443die(_("'%s' or '%s' cannot be used with%s"), 444"--ours","--theirs","--staged"); 445 446if(opts->checkout_index && !opts->checkout_worktree && 447 opts->merge) 448die(_("'%s' or '%s' cannot be used with%s"), 449"--merge","--conflict","--staged"); 450 451if(opts->patch_mode) { 452const char*patch_mode; 453 454if(opts->checkout_index && opts->checkout_worktree) 455 patch_mode ="--patch=checkout"; 456else if(opts->checkout_index && !opts->checkout_worktree) 457 patch_mode ="--patch=reset"; 458else if(!opts->checkout_index && opts->checkout_worktree) 459 patch_mode ="--patch=worktree"; 460else 461BUG("either flag must have been set, worktree=%d, index=%d", 462 opts->checkout_worktree, opts->checkout_index); 463returnrun_add_interactive(revision, patch_mode, &opts->pathspec); 464} 465 466repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR); 467if(read_cache_preload(&opts->pathspec) <0) 468returnerror(_("index file corrupt")); 469 470if(opts->source_tree) 471read_tree_some(opts->source_tree, &opts->pathspec); 472 473 ps_matched =xcalloc(opts->pathspec.nr,1); 474 475/* 476 * Make sure all pathspecs participated in locating the paths 477 * to be checked out. 478 */ 479for(pos =0; pos < active_nr; pos++) 480if(opts->overlay_mode) 481mark_ce_for_checkout_overlay(active_cache[pos], 482 ps_matched, 483 opts); 484else 485mark_ce_for_checkout_no_overlay(active_cache[pos], 486 ps_matched, 487 opts); 488 489if(report_path_error(ps_matched, &opts->pathspec)) { 490free(ps_matched); 491return1; 492} 493free(ps_matched); 494 495/* "checkout -m path" to recreate conflicted state */ 496if(opts->merge) 497unmerge_marked_index(&the_index); 498 499/* Any unmerged paths? */ 500for(pos =0; pos < active_nr; pos++) { 501const struct cache_entry *ce = active_cache[pos]; 502if(ce->ce_flags & CE_MATCHED) { 503if(!ce_stage(ce)) 504continue; 505if(opts->ignore_unmerged) { 506if(!opts->quiet) 507warning(_("path '%s' is unmerged"), ce->name); 508}else if(opts->writeout_stage) { 509 errs |=check_stage(opts->writeout_stage, ce, pos, opts->overlay_mode); 510}else if(opts->merge) { 511 errs |=check_stages((1<<2) | (1<<3), ce, pos); 512}else{ 513 errs =1; 514error(_("path '%s' is unmerged"), ce->name); 515} 516 pos =skip_same_name(ce, pos) -1; 517} 518} 519if(errs) 520return1; 521 522/* Now we are committed to check them out */ 523if(opts->checkout_worktree) 524 errs |=checkout_worktree(opts); 525 526/* 527 * Allow updating the index when checking out from the index. 528 * This is to save new stat info. 529 */ 530if(opts->checkout_worktree && !opts->checkout_index && !opts->source_tree) 531 checkout_index =1; 532else 533 checkout_index = opts->checkout_index; 534 535if(checkout_index) { 536if(write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) 537die(_("unable to write new index file")); 538}else{ 539/* 540 * NEEDSWORK: if --worktree is not specified, we 541 * should save stat info of checked out files in the 542 * index to avoid the next (potentially costly) 543 * refresh. But it's a bit tricker to do... 544 */ 545rollback_lock_file(&lock_file); 546} 547 548read_ref_full("HEAD",0, &rev, NULL); 549 head =lookup_commit_reference_gently(the_repository, &rev,1); 550 551 errs |=post_checkout_hook(head, head,0); 552return errs; 553} 554 555static voidshow_local_changes(struct object *head, 556const struct diff_options *opts) 557{ 558struct rev_info rev; 559/* I think we want full paths, even if we're in a subdirectory. */ 560repo_init_revisions(the_repository, &rev, NULL); 561 rev.diffopt.flags = opts->flags; 562 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS; 563diff_setup_done(&rev.diffopt); 564add_pending_object(&rev, head, NULL); 565run_diff_index(&rev,0); 566} 567 568static voiddescribe_detached_head(const char*msg,struct commit *commit) 569{ 570struct strbuf sb = STRBUF_INIT; 571 572if(!parse_commit(commit)) 573pp_commit_easy(CMIT_FMT_ONELINE, commit, &sb); 574if(print_sha1_ellipsis()) { 575fprintf(stderr,"%s %s...%s\n", msg, 576find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV), sb.buf); 577}else{ 578fprintf(stderr,"%s %s %s\n", msg, 579find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV), sb.buf); 580} 581strbuf_release(&sb); 582} 583 584static intreset_tree(struct tree *tree,const struct checkout_opts *o, 585int worktree,int*writeout_error) 586{ 587struct unpack_trees_options opts; 588struct tree_desc tree_desc; 589 590memset(&opts,0,sizeof(opts)); 591 opts.head_idx = -1; 592 opts.update = worktree; 593 opts.skip_unmerged = !worktree; 594 opts.reset =1; 595 opts.merge =1; 596 opts.fn = oneway_merge; 597 opts.verbose_update = o->show_progress; 598 opts.src_index = &the_index; 599 opts.dst_index = &the_index; 600parse_tree(tree); 601init_tree_desc(&tree_desc, tree->buffer, tree->size); 602switch(unpack_trees(1, &tree_desc, &opts)) { 603case-2: 604*writeout_error =1; 605/* 606 * We return 0 nevertheless, as the index is all right 607 * and more importantly we have made best efforts to 608 * update paths in the work tree, and we cannot revert 609 * them. 610 */ 611/* fallthrough */ 612case0: 613return0; 614default: 615return128; 616} 617} 618 619struct branch_info { 620const char*name;/* The short name used */ 621const char*path;/* The full name of a real branch */ 622struct commit *commit;/* The named commit */ 623/* 624 * if not null the branch is detached because it's already 625 * checked out in this checkout 626 */ 627char*checkout; 628}; 629 630static voidsetup_branch_path(struct branch_info *branch) 631{ 632struct strbuf buf = STRBUF_INIT; 633 634strbuf_branchname(&buf, branch->name, INTERPRET_BRANCH_LOCAL); 635if(strcmp(buf.buf, branch->name)) 636 branch->name =xstrdup(buf.buf); 637strbuf_splice(&buf,0,0,"refs/heads/",11); 638 branch->path =strbuf_detach(&buf, NULL); 639} 640 641static intmerge_working_tree(const struct checkout_opts *opts, 642struct branch_info *old_branch_info, 643struct branch_info *new_branch_info, 644int*writeout_error) 645{ 646int ret; 647struct lock_file lock_file = LOCK_INIT; 648struct tree *new_tree; 649 650hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR); 651if(read_cache_preload(NULL) <0) 652returnerror(_("index file corrupt")); 653 654resolve_undo_clear(); 655if(opts->new_orphan_branch && opts->orphan_from_empty_tree) { 656if(new_branch_info->commit) 657BUG("'switch --orphan' should never accept a commit as starting point"); 658 new_tree =parse_tree_indirect(the_hash_algo->empty_tree); 659}else 660 new_tree =get_commit_tree(new_branch_info->commit); 661if(opts->discard_changes) { 662 ret =reset_tree(new_tree, opts,1, writeout_error); 663if(ret) 664return ret; 665}else{ 666struct tree_desc trees[2]; 667struct tree *tree; 668struct unpack_trees_options topts; 669 670memset(&topts,0,sizeof(topts)); 671 topts.head_idx = -1; 672 topts.src_index = &the_index; 673 topts.dst_index = &the_index; 674 675setup_unpack_trees_porcelain(&topts,"checkout"); 676 677refresh_cache(REFRESH_QUIET); 678 679if(unmerged_cache()) { 680error(_("you need to resolve your current index first")); 681return1; 682} 683 684/* 2-way merge to the new branch */ 685 topts.initial_checkout =is_cache_unborn(); 686 topts.update =1; 687 topts.merge =1; 688 topts.quiet = opts->merge && old_branch_info->commit; 689 topts.verbose_update = opts->show_progress; 690 topts.fn = twoway_merge; 691if(opts->overwrite_ignore) { 692 topts.dir =xcalloc(1,sizeof(*topts.dir)); 693 topts.dir->flags |= DIR_SHOW_IGNORED; 694setup_standard_excludes(topts.dir); 695} 696 tree =parse_tree_indirect(old_branch_info->commit ? 697&old_branch_info->commit->object.oid : 698 the_hash_algo->empty_tree); 699init_tree_desc(&trees[0], tree->buffer, tree->size); 700parse_tree(new_tree); 701 tree = new_tree; 702init_tree_desc(&trees[1], tree->buffer, tree->size); 703 704 ret =unpack_trees(2, trees, &topts); 705clear_unpack_trees_porcelain(&topts); 706if(ret == -1) { 707/* 708 * Unpack couldn't do a trivial merge; either 709 * give up or do a real merge, depending on 710 * whether the merge flag was used. 711 */ 712struct tree *result; 713struct tree *work; 714struct tree *old_tree; 715struct merge_options o; 716struct strbuf sb = STRBUF_INIT; 717 718if(!opts->merge) 719return1; 720 721/* 722 * Without old_branch_info->commit, the below is the same as 723 * the two-tree unpack we already tried and failed. 724 */ 725if(!old_branch_info->commit) 726return1; 727 old_tree =get_commit_tree(old_branch_info->commit); 728 729if(repo_index_has_changes(the_repository, old_tree, &sb)) 730die(_("cannot continue with staged changes in " 731"the following files:\n%s"), sb.buf); 732strbuf_release(&sb); 733 734if(repo_index_has_changes(the_repository, 735get_commit_tree(old_branch_info->commit), 736&sb)) 737warning(_("staged changes in the following files may be lost:%s"), 738 sb.buf); 739strbuf_release(&sb); 740 741/* Do more real merge */ 742 743/* 744 * We update the index fully, then write the 745 * tree from the index, then merge the new 746 * branch with the current tree, with the old 747 * branch as the base. Then we reset the index 748 * (but not the working tree) to the new 749 * branch, leaving the working tree as the 750 * merged version, but skipping unmerged 751 * entries in the index. 752 */ 753 754add_files_to_cache(NULL, NULL,0); 755/* 756 * NEEDSWORK: carrying over local changes 757 * when branches have different end-of-line 758 * normalization (or clean+smudge rules) is 759 * a pain; plumb in an option to set 760 * o.renormalize? 761 */ 762init_merge_options(&o, the_repository); 763 o.verbosity =0; 764 work =write_tree_from_memory(&o); 765 766 ret =reset_tree(new_tree, 767 opts,1, 768 writeout_error); 769if(ret) 770return ret; 771 o.ancestor = old_branch_info->name; 772 o.branch1 = new_branch_info->name; 773 o.branch2 ="local"; 774 ret =merge_trees(&o, 775 new_tree, 776 work, 777 old_tree, 778&result); 779if(ret <0) 780exit(128); 781 ret =reset_tree(new_tree, 782 opts,0, 783 writeout_error); 784strbuf_release(&o.obuf); 785if(ret) 786return ret; 787} 788} 789 790if(!active_cache_tree) 791 active_cache_tree =cache_tree(); 792 793if(!cache_tree_fully_valid(active_cache_tree)) 794cache_tree_update(&the_index, WRITE_TREE_SILENT | WRITE_TREE_REPAIR); 795 796if(write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) 797die(_("unable to write new index file")); 798 799if(!opts->discard_changes && !opts->quiet && new_branch_info->commit) 800show_local_changes(&new_branch_info->commit->object, &opts->diff_options); 801 802return0; 803} 804 805static voidreport_tracking(struct branch_info *new_branch_info) 806{ 807struct strbuf sb = STRBUF_INIT; 808struct branch *branch =branch_get(new_branch_info->name); 809 810if(!format_tracking_info(branch, &sb, AHEAD_BEHIND_FULL)) 811return; 812fputs(sb.buf, stdout); 813strbuf_release(&sb); 814} 815 816static voidupdate_refs_for_switch(const struct checkout_opts *opts, 817struct branch_info *old_branch_info, 818struct branch_info *new_branch_info) 819{ 820struct strbuf msg = STRBUF_INIT; 821const char*old_desc, *reflog_msg; 822if(opts->new_branch) { 823if(opts->new_orphan_branch) { 824char*refname; 825 826 refname =mkpathdup("refs/heads/%s", opts->new_orphan_branch); 827if(opts->new_branch_log && 828!should_autocreate_reflog(refname)) { 829int ret; 830struct strbuf err = STRBUF_INIT; 831 832 ret =safe_create_reflog(refname,1, &err); 833if(ret) { 834fprintf(stderr,_("Can not do reflog for '%s':%s\n"), 835 opts->new_orphan_branch, err.buf); 836strbuf_release(&err); 837free(refname); 838return; 839} 840strbuf_release(&err); 841} 842free(refname); 843} 844else 845create_branch(the_repository, 846 opts->new_branch, new_branch_info->name, 847 opts->new_branch_force ?1:0, 848 opts->new_branch_force ?1:0, 849 opts->new_branch_log, 850 opts->quiet, 851 opts->track); 852 new_branch_info->name = opts->new_branch; 853setup_branch_path(new_branch_info); 854} 855 856 old_desc = old_branch_info->name; 857if(!old_desc && old_branch_info->commit) 858 old_desc =oid_to_hex(&old_branch_info->commit->object.oid); 859 860 reflog_msg =getenv("GIT_REFLOG_ACTION"); 861if(!reflog_msg) 862strbuf_addf(&msg,"checkout: moving from%sto%s", 863 old_desc ? old_desc :"(invalid)", new_branch_info->name); 864else 865strbuf_insert(&msg,0, reflog_msg,strlen(reflog_msg)); 866 867if(!strcmp(new_branch_info->name,"HEAD") && !new_branch_info->path && !opts->force_detach) { 868/* Nothing to do. */ 869}else if(opts->force_detach || !new_branch_info->path) {/* No longer on any branch. */ 870update_ref(msg.buf,"HEAD", &new_branch_info->commit->object.oid, NULL, 871 REF_NO_DEREF, UPDATE_REFS_DIE_ON_ERR); 872if(!opts->quiet) { 873if(old_branch_info->path && 874 advice_detached_head && !opts->force_detach) 875detach_advice(new_branch_info->name); 876describe_detached_head(_("HEAD is now at"), new_branch_info->commit); 877} 878}else if(new_branch_info->path) {/* Switch branches. */ 879if(create_symref("HEAD", new_branch_info->path, msg.buf) <0) 880die(_("unable to update HEAD")); 881if(!opts->quiet) { 882if(old_branch_info->path && !strcmp(new_branch_info->path, old_branch_info->path)) { 883if(opts->new_branch_force) 884fprintf(stderr,_("Reset branch '%s'\n"), 885 new_branch_info->name); 886else 887fprintf(stderr,_("Already on '%s'\n"), 888 new_branch_info->name); 889}else if(opts->new_branch) { 890if(opts->branch_exists) 891fprintf(stderr,_("Switched to and reset branch '%s'\n"), new_branch_info->name); 892else 893fprintf(stderr,_("Switched to a new branch '%s'\n"), new_branch_info->name); 894}else{ 895fprintf(stderr,_("Switched to branch '%s'\n"), 896 new_branch_info->name); 897} 898} 899if(old_branch_info->path && old_branch_info->name) { 900if(!ref_exists(old_branch_info->path) &&reflog_exists(old_branch_info->path)) 901delete_reflog(old_branch_info->path); 902} 903} 904remove_branch_state(the_repository, !opts->quiet); 905strbuf_release(&msg); 906if(!opts->quiet && 907(new_branch_info->path || (!opts->force_detach && !strcmp(new_branch_info->name,"HEAD")))) 908report_tracking(new_branch_info); 909} 910 911static intadd_pending_uninteresting_ref(const char*refname, 912const struct object_id *oid, 913int flags,void*cb_data) 914{ 915add_pending_oid(cb_data, refname, oid, UNINTERESTING); 916return0; 917} 918 919static voiddescribe_one_orphan(struct strbuf *sb,struct commit *commit) 920{ 921strbuf_addstr(sb," "); 922strbuf_add_unique_abbrev(sb, &commit->object.oid, DEFAULT_ABBREV); 923strbuf_addch(sb,' '); 924if(!parse_commit(commit)) 925pp_commit_easy(CMIT_FMT_ONELINE, commit, sb); 926strbuf_addch(sb,'\n'); 927} 928 929#define ORPHAN_CUTOFF 4 930static voidsuggest_reattach(struct commit *commit,struct rev_info *revs) 931{ 932struct commit *c, *last = NULL; 933struct strbuf sb = STRBUF_INIT; 934int lost =0; 935while((c =get_revision(revs)) != NULL) { 936if(lost < ORPHAN_CUTOFF) 937describe_one_orphan(&sb, c); 938 last = c; 939 lost++; 940} 941if(ORPHAN_CUTOFF < lost) { 942int more = lost - ORPHAN_CUTOFF; 943if(more ==1) 944describe_one_orphan(&sb, last); 945else 946strbuf_addf(&sb,_(" ... and%dmore.\n"), more); 947} 948 949fprintf(stderr, 950Q_( 951/* The singular version */ 952"Warning: you are leaving%dcommit behind, " 953"not connected to\n" 954"any of your branches:\n\n" 955"%s\n", 956/* The plural version */ 957"Warning: you are leaving%dcommits behind, " 958"not connected to\n" 959"any of your branches:\n\n" 960"%s\n", 961/* Give ngettext() the count */ 962 lost), 963 lost, 964 sb.buf); 965strbuf_release(&sb); 966 967if(advice_detached_head) 968fprintf(stderr, 969Q_( 970/* The singular version */ 971"If you want to keep it by creating a new branch, " 972"this may be a good time\nto do so with:\n\n" 973" git branch <new-branch-name>%s\n\n", 974/* The plural version */ 975"If you want to keep them by creating a new branch, " 976"this may be a good time\nto do so with:\n\n" 977" git branch <new-branch-name>%s\n\n", 978/* Give ngettext() the count */ 979 lost), 980find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV)); 981} 982 983/* 984 * We are about to leave commit that was at the tip of a detached 985 * HEAD. If it is not reachable from any ref, this is the last chance 986 * for the user to do so without resorting to reflog. 987 */ 988static voidorphaned_commit_warning(struct commit *old_commit,struct commit *new_commit) 989{ 990struct rev_info revs; 991struct object *object = &old_commit->object; 992 993repo_init_revisions(the_repository, &revs, NULL); 994setup_revisions(0, NULL, &revs, NULL); 995 996 object->flags &= ~UNINTERESTING; 997add_pending_object(&revs, object,oid_to_hex(&object->oid)); 998 999for_each_ref(add_pending_uninteresting_ref, &revs);1000if(new_commit)1001add_pending_oid(&revs,"HEAD",1002&new_commit->object.oid,1003 UNINTERESTING);10041005if(prepare_revision_walk(&revs))1006die(_("internal error in revision walk"));1007if(!(old_commit->object.flags & UNINTERESTING))1008suggest_reattach(old_commit, &revs);1009else1010describe_detached_head(_("Previous HEAD position was"), old_commit);10111012/* Clean up objects used, as they will be reused. */1013clear_commit_marks_all(ALL_REV_FLAGS);1014}10151016static intswitch_branches(const struct checkout_opts *opts,1017struct branch_info *new_branch_info)1018{1019int ret =0;1020struct branch_info old_branch_info;1021void*path_to_free;1022struct object_id rev;1023int flag, writeout_error =0;1024int do_merge =1;10251026trace2_cmd_mode("branch");10271028memset(&old_branch_info,0,sizeof(old_branch_info));1029 old_branch_info.path = path_to_free =resolve_refdup("HEAD",0, &rev, &flag);1030if(old_branch_info.path)1031 old_branch_info.commit =lookup_commit_reference_gently(the_repository, &rev,1);1032if(!(flag & REF_ISSYMREF))1033 old_branch_info.path = NULL;10341035if(old_branch_info.path)1036skip_prefix(old_branch_info.path,"refs/heads/", &old_branch_info.name);10371038if(opts->new_orphan_branch && opts->orphan_from_empty_tree) {1039if(new_branch_info->name)1040BUG("'switch --orphan' should never accept a commit as starting point");1041 new_branch_info->commit = NULL;1042 new_branch_info->name ="(empty)";1043 do_merge =1;1044}10451046if(!new_branch_info->name) {1047 new_branch_info->name ="HEAD";1048 new_branch_info->commit = old_branch_info.commit;1049if(!new_branch_info->commit)1050die(_("You are on a branch yet to be born"));1051parse_commit_or_die(new_branch_info->commit);10521053if(opts->only_merge_on_switching_branches)1054 do_merge =0;1055}10561057if(do_merge) {1058 ret =merge_working_tree(opts, &old_branch_info, new_branch_info, &writeout_error);1059if(ret) {1060free(path_to_free);1061return ret;1062}1063}10641065if(!opts->quiet && !old_branch_info.path && old_branch_info.commit && new_branch_info->commit != old_branch_info.commit)1066orphaned_commit_warning(old_branch_info.commit, new_branch_info->commit);10671068update_refs_for_switch(opts, &old_branch_info, new_branch_info);10691070 ret =post_checkout_hook(old_branch_info.commit, new_branch_info->commit,1);1071free(path_to_free);1072return ret || writeout_error;1073}10741075static intgit_checkout_config(const char*var,const char*value,void*cb)1076{1077if(!strcmp(var,"diff.ignoresubmodules")) {1078struct checkout_opts *opts = cb;1079handle_ignore_submodules_arg(&opts->diff_options, value);1080return0;1081}10821083if(starts_with(var,"submodule."))1084returngit_default_submodule_config(var, value, NULL);10851086returngit_xmerge_config(var, value, NULL);1087}10881089static voidsetup_new_branch_info_and_source_tree(1090struct branch_info *new_branch_info,1091struct checkout_opts *opts,1092struct object_id *rev,1093const char*arg)1094{1095struct tree **source_tree = &opts->source_tree;1096struct object_id branch_rev;10971098 new_branch_info->name = arg;1099setup_branch_path(new_branch_info);11001101if(!check_refname_format(new_branch_info->path,0) &&1102!read_ref(new_branch_info->path, &branch_rev))1103oidcpy(rev, &branch_rev);1104else1105 new_branch_info->path = NULL;/* not an existing branch */11061107 new_branch_info->commit =lookup_commit_reference_gently(the_repository, rev,1);1108if(!new_branch_info->commit) {1109/* not a commit */1110*source_tree =parse_tree_indirect(rev);1111}else{1112parse_commit_or_die(new_branch_info->commit);1113*source_tree =get_commit_tree(new_branch_info->commit);1114}1115}11161117static intparse_branchname_arg(int argc,const char**argv,1118int dwim_new_local_branch_ok,1119struct branch_info *new_branch_info,1120struct checkout_opts *opts,1121struct object_id *rev,1122int*dwim_remotes_matched)1123{1124const char**new_branch = &opts->new_branch;1125int argcount =0;1126const char*arg;1127int dash_dash_pos;1128int has_dash_dash =0;1129int i;11301131/*1132 * case 1: git checkout <ref> -- [<paths>]1133 *1134 * <ref> must be a valid tree, everything after the '--' must be1135 * a path.1136 *1137 * case 2: git checkout -- [<paths>]1138 *1139 * everything after the '--' must be paths.1140 *1141 * case 3: git checkout <something> [--]1142 *1143 * (a) If <something> is a commit, that is to1144 * switch to the branch or detach HEAD at it. As a special case,1145 * if <something> is A...B (missing A or B means HEAD but you can1146 * omit at most one side), and if there is a unique merge base1147 * between A and B, A...B names that merge base.1148 *1149 * (b) If <something> is _not_ a commit, either "--" is present1150 * or <something> is not a path, no -t or -b was given, and1151 * and there is a tracking branch whose name is <something>1152 * in one and only one remote (or if the branch exists on the1153 * remote named in checkout.defaultRemote), then this is a1154 * short-hand to fork local <something> from that1155 * remote-tracking branch.1156 *1157 * (c) Otherwise, if "--" is present, treat it like case (1).1158 *1159 * (d) Otherwise :1160 * - if it's a reference, treat it like case (1)1161 * - else if it's a path, treat it like case (2)1162 * - else: fail.1163 *1164 * case 4: git checkout <something> <paths>1165 *1166 * The first argument must not be ambiguous.1167 * - If it's *only* a reference, treat it like case (1).1168 * - If it's only a path, treat it like case (2).1169 * - else: fail.1170 *1171 */1172if(!argc)1173return0;11741175if(!opts->accept_pathspec) {1176if(argc >1)1177die(_("only one reference expected"));1178 has_dash_dash =1;/* helps disambiguate */1179}11801181 arg = argv[0];1182 dash_dash_pos = -1;1183for(i =0; i < argc; i++) {1184if(opts->accept_pathspec && !strcmp(argv[i],"--")) {1185 dash_dash_pos = i;1186break;1187}1188}1189if(dash_dash_pos ==0)1190return1;/* case (2) */1191else if(dash_dash_pos ==1)1192 has_dash_dash =1;/* case (3) or (1) */1193else if(dash_dash_pos >=2)1194die(_("only one reference expected,%dgiven."), dash_dash_pos);1195 opts->count_checkout_paths = !opts->quiet && !has_dash_dash;11961197if(!strcmp(arg,"-"))1198 arg ="@{-1}";11991200if(get_oid_mb(arg, rev)) {1201/*1202 * Either case (3) or (4), with <something> not being1203 * a commit, or an attempt to use case (1) with an1204 * invalid ref.1205 *1206 * It's likely an error, but we need to find out if1207 * we should auto-create the branch, case (3).(b).1208 */1209int recover_with_dwim = dwim_new_local_branch_ok;12101211int could_be_checkout_paths = !has_dash_dash &&1212check_filename(opts->prefix, arg);12131214if(!has_dash_dash && !no_wildcard(arg))1215 recover_with_dwim =0;12161217/*1218 * Accept "git checkout foo", "git checkout foo --"1219 * and "git switch foo" as candidates for dwim.1220 */1221if(!(argc ==1&& !has_dash_dash) &&1222!(argc ==2&& has_dash_dash) &&1223 opts->accept_pathspec)1224 recover_with_dwim =0;12251226if(recover_with_dwim) {1227const char*remote =unique_tracking_name(arg, rev,1228 dwim_remotes_matched);1229if(remote) {1230if(could_be_checkout_paths)1231die(_("'%s' could be both a local file and a tracking branch.\n"1232"Please use -- (and optionally --no-guess) to disambiguate"),1233 arg);1234*new_branch = arg;1235 arg = remote;1236/* DWIMmed to create local branch, case (3).(b) */1237}else{1238 recover_with_dwim =0;1239}1240}12411242if(!recover_with_dwim) {1243if(has_dash_dash)1244die(_("invalid reference:%s"), arg);1245return argcount;1246}1247}12481249/* we can't end up being in (2) anymore, eat the argument */1250 argcount++;1251 argv++;1252 argc--;12531254setup_new_branch_info_and_source_tree(new_branch_info, opts, rev, arg);12551256if(!opts->source_tree)/* case (1): want a tree */1257die(_("reference is not a tree:%s"), arg);12581259if(!has_dash_dash) {/* case (3).(d) -> (1) */1260/*1261 * Do not complain the most common case1262 * git checkout branch1263 * even if there happen to be a file called 'branch';1264 * it would be extremely annoying.1265 */1266if(argc)1267verify_non_filename(opts->prefix, arg);1268}else if(opts->accept_pathspec) {1269 argcount++;1270 argv++;1271 argc--;1272}12731274return argcount;1275}12761277static intswitch_unborn_to_new_branch(const struct checkout_opts *opts)1278{1279int status;1280struct strbuf branch_ref = STRBUF_INIT;12811282trace2_cmd_mode("unborn");12831284if(!opts->new_branch)1285die(_("You are on a branch yet to be born"));1286strbuf_addf(&branch_ref,"refs/heads/%s", opts->new_branch);1287 status =create_symref("HEAD", branch_ref.buf,"checkout -b");1288strbuf_release(&branch_ref);1289if(!opts->quiet)1290fprintf(stderr,_("Switched to a new branch '%s'\n"),1291 opts->new_branch);1292return status;1293}12941295static voiddie_expecting_a_branch(const struct branch_info *branch_info)1296{1297struct object_id oid;1298char*to_free;12991300if(dwim_ref(branch_info->name,strlen(branch_info->name), &oid, &to_free) ==1) {1301const char*ref = to_free;13021303if(skip_prefix(ref,"refs/tags/", &ref))1304die(_("a branch is expected, got tag '%s'"), ref);1305if(skip_prefix(ref,"refs/remotes/", &ref))1306die(_("a branch is expected, got remote branch '%s'"), ref);1307die(_("a branch is expected, got '%s'"), ref);1308}1309if(branch_info->commit)1310die(_("a branch is expected, got commit '%s'"), branch_info->name);1311/*1312 * This case should never happen because we already die() on1313 * non-commit, but just in case.1314 */1315die(_("a branch is expected, got '%s'"), branch_info->name);1316}13171318static voiddie_if_some_operation_in_progress(void)1319{1320struct wt_status_state state;13211322memset(&state,0,sizeof(state));1323wt_status_get_state(the_repository, &state,0);13241325if(state.merge_in_progress)1326die(_("cannot switch branch while merging\n"1327"Consider\"git merge --quit\""1328"or\"git worktree add\"."));1329if(state.am_in_progress)1330die(_("cannot switch branch in the middle of an am session\n"1331"Consider\"git am --quit\""1332"or\"git worktree add\"."));1333if(state.rebase_interactive_in_progress || state.rebase_in_progress)1334die(_("cannot switch branch while rebasing\n"1335"Consider\"git rebase --quit\""1336"or\"git worktree add\"."));1337if(state.cherry_pick_in_progress)1338die(_("cannot switch branch while cherry-picking\n"1339"Consider\"git cherry-pick --quit\""1340"or\"git worktree add\"."));1341if(state.revert_in_progress)1342die(_("cannot switch branch while reverting\n"1343"Consider\"git revert --quit\""1344"or\"git worktree add\"."));1345if(state.bisect_in_progress)1346warning(_("you are switching branch while bisecting"));1347}13481349static intcheckout_branch(struct checkout_opts *opts,1350struct branch_info *new_branch_info)1351{1352if(opts->pathspec.nr)1353die(_("paths cannot be used with switching branches"));13541355if(opts->patch_mode)1356die(_("'%s' cannot be used with switching branches"),1357"--patch");13581359if(opts->overlay_mode != -1)1360die(_("'%s' cannot be used with switching branches"),1361"--[no]-overlay");13621363if(opts->writeout_stage)1364die(_("'%s' cannot be used with switching branches"),1365"--ours/--theirs");13661367if(opts->force && opts->merge)1368die(_("'%s' cannot be used with '%s'"),"-f","-m");13691370if(opts->discard_changes && opts->merge)1371die(_("'%s' cannot be used with '%s'"),"--discard-changes","--merge");13721373if(opts->force_detach && opts->new_branch)1374die(_("'%s' cannot be used with '%s'"),1375"--detach","-b/-B/--orphan");13761377if(opts->new_orphan_branch) {1378if(opts->track != BRANCH_TRACK_UNSPECIFIED)1379die(_("'%s' cannot be used with '%s'"),"--orphan","-t");1380if(opts->orphan_from_empty_tree && new_branch_info->name)1381die(_("'%s' cannot take <start-point>"),"--orphan");1382}else if(opts->force_detach) {1383if(opts->track != BRANCH_TRACK_UNSPECIFIED)1384die(_("'%s' cannot be used with '%s'"),"--detach","-t");1385}else if(opts->track == BRANCH_TRACK_UNSPECIFIED)1386 opts->track = git_branch_track;13871388if(new_branch_info->name && !new_branch_info->commit)1389die(_("Cannot switch branch to a non-commit '%s'"),1390 new_branch_info->name);13911392if(!opts->switch_branch_doing_nothing_is_ok &&1393!new_branch_info->name &&1394!opts->new_branch &&1395!opts->force_detach)1396die(_("missing branch or commit argument"));13971398if(!opts->implicit_detach &&1399!opts->force_detach &&1400!opts->new_branch &&1401!opts->new_branch_force &&1402 new_branch_info->name &&1403!new_branch_info->path)1404die_expecting_a_branch(new_branch_info);14051406if(!opts->can_switch_when_in_progress)1407die_if_some_operation_in_progress();14081409if(new_branch_info->path && !opts->force_detach && !opts->new_branch &&1410!opts->ignore_other_worktrees) {1411int flag;1412char*head_ref =resolve_refdup("HEAD",0, NULL, &flag);1413if(head_ref &&1414(!(flag & REF_ISSYMREF) ||strcmp(head_ref, new_branch_info->path)))1415die_if_checked_out(new_branch_info->path,1);1416free(head_ref);1417}14181419if(!new_branch_info->commit && opts->new_branch) {1420struct object_id rev;1421int flag;14221423if(!read_ref_full("HEAD",0, &rev, &flag) &&1424(flag & REF_ISSYMREF) &&is_null_oid(&rev))1425returnswitch_unborn_to_new_branch(opts);1426}1427returnswitch_branches(opts, new_branch_info);1428}14291430static struct option *add_common_options(struct checkout_opts *opts,1431struct option *prevopts)1432{1433struct option options[] = {1434OPT__QUIET(&opts->quiet,N_("suppress progress reporting")),1435{ OPTION_CALLBACK,0,"recurse-submodules", NULL,1436"checkout","control recursive updating of submodules",1437 PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater },1438OPT_BOOL(0,"progress", &opts->show_progress,N_("force progress reporting")),1439OPT_BOOL('m',"merge", &opts->merge,N_("perform a 3-way merge with the new branch")),1440OPT_STRING(0,"conflict", &opts->conflict_style,N_("style"),1441N_("conflict style (merge or diff3)")),1442OPT_END()1443};1444struct option *newopts =parse_options_concat(prevopts, options);1445free(prevopts);1446return newopts;1447}14481449static struct option *add_common_switch_branch_options(1450struct checkout_opts *opts,struct option *prevopts)1451{1452struct option options[] = {1453OPT_BOOL('d',"detach", &opts->force_detach,N_("detach HEAD at named commit")),1454OPT_SET_INT('t',"track", &opts->track,N_("set upstream info for new branch"),1455 BRANCH_TRACK_EXPLICIT),1456OPT__FORCE(&opts->force,N_("force checkout (throw away local modifications)"),1457 PARSE_OPT_NOCOMPLETE),1458OPT_STRING(0,"orphan", &opts->new_orphan_branch,N_("new-branch"),N_("new unparented branch")),1459OPT_BOOL_F(0,"overwrite-ignore", &opts->overwrite_ignore,1460N_("update ignored files (default)"),1461 PARSE_OPT_NOCOMPLETE),1462OPT_BOOL(0,"ignore-other-worktrees", &opts->ignore_other_worktrees,1463N_("do not check if another worktree is holding the given ref")),1464OPT_END()1465};1466struct option *newopts =parse_options_concat(prevopts, options);1467free(prevopts);1468return newopts;1469}14701471static struct option *add_checkout_path_options(struct checkout_opts *opts,1472struct option *prevopts)1473{1474struct option options[] = {1475OPT_SET_INT_F('2',"ours", &opts->writeout_stage,1476N_("checkout our version for unmerged files"),14772, PARSE_OPT_NONEG),1478OPT_SET_INT_F('3',"theirs", &opts->writeout_stage,1479N_("checkout their version for unmerged files"),14803, PARSE_OPT_NONEG),1481OPT_BOOL('p',"patch", &opts->patch_mode,N_("select hunks interactively")),1482OPT_BOOL(0,"ignore-skip-worktree-bits", &opts->ignore_skipworktree,1483N_("do not limit pathspecs to sparse entries only")),1484OPT_END()1485};1486struct option *newopts =parse_options_concat(prevopts, options);1487free(prevopts);1488return newopts;1489}14901491static intcheckout_main(int argc,const char**argv,const char*prefix,1492struct checkout_opts *opts,struct option *options,1493const char*const usagestr[])1494{1495struct branch_info new_branch_info;1496int dwim_remotes_matched =0;1497int parseopt_flags =0;14981499memset(&new_branch_info,0,sizeof(new_branch_info));1500 opts->overwrite_ignore =1;1501 opts->prefix = prefix;1502 opts->show_progress = -1;15031504git_config(git_checkout_config, opts);15051506 opts->track = BRANCH_TRACK_UNSPECIFIED;15071508if(!opts->accept_pathspec && !opts->accept_ref)1509BUG("make up your mind, you need to take _something_");1510if(opts->accept_pathspec && opts->accept_ref)1511 parseopt_flags = PARSE_OPT_KEEP_DASHDASH;15121513 argc =parse_options(argc, argv, prefix, options,1514 usagestr, parseopt_flags);15151516if(opts->show_progress <0) {1517if(opts->quiet)1518 opts->show_progress =0;1519else1520 opts->show_progress =isatty(2);1521}15221523if(opts->conflict_style) {1524 opts->merge =1;/* implied */1525git_xmerge_config("merge.conflictstyle", opts->conflict_style, NULL);1526}1527if(opts->force) {1528 opts->discard_changes =1;1529 opts->ignore_unmerged_opt ="--force";1530 opts->ignore_unmerged =1;1531}15321533if((!!opts->new_branch + !!opts->new_branch_force + !!opts->new_orphan_branch) >1)1534die(_("-b, -B and --orphan are mutually exclusive"));15351536if(opts->overlay_mode ==1&& opts->patch_mode)1537die(_("-p and --overlay are mutually exclusive"));15381539if(opts->checkout_index >=0|| opts->checkout_worktree >=0) {1540if(opts->checkout_index <0)1541 opts->checkout_index =0;1542if(opts->checkout_worktree <0)1543 opts->checkout_worktree =0;1544}else{1545if(opts->checkout_index <0)1546 opts->checkout_index = -opts->checkout_index -1;1547if(opts->checkout_worktree <0)1548 opts->checkout_worktree = -opts->checkout_worktree -1;1549}1550if(opts->checkout_index <0|| opts->checkout_worktree <0)1551BUG("these flags should be non-negative by now");1552/*1553 * convenient shortcut: "git restore --staged" equals1554 * "git restore --staged --source HEAD"1555 */1556if(!opts->from_treeish && opts->checkout_index && !opts->checkout_worktree)1557 opts->from_treeish ="HEAD";15581559/*1560 * From here on, new_branch will contain the branch to be checked out,1561 * and new_branch_force and new_orphan_branch will tell us which one of1562 * -b/-B/--orphan is being used.1563 */1564if(opts->new_branch_force)1565 opts->new_branch = opts->new_branch_force;15661567if(opts->new_orphan_branch)1568 opts->new_branch = opts->new_orphan_branch;15691570/* --track without -b/-B/--orphan should DWIM */1571if(opts->track != BRANCH_TRACK_UNSPECIFIED && !opts->new_branch) {1572const char*argv0 = argv[0];1573if(!argc || !strcmp(argv0,"--"))1574die(_("--track needs a branch name"));1575skip_prefix(argv0,"refs/", &argv0);1576skip_prefix(argv0,"remotes/", &argv0);1577 argv0 =strchr(argv0,'/');1578if(!argv0 || !argv0[1])1579die(_("missing branch name; try -b"));1580 opts->new_branch = argv0 +1;1581}15821583/*1584 * Extract branch name from command line arguments, so1585 * all that is left is pathspecs.1586 *1587 * Handle1588 *1589 * 1) git checkout <tree> -- [<paths>]1590 * 2) git checkout -- [<paths>]1591 * 3) git checkout <something> [<paths>]1592 *1593 * including "last branch" syntax and DWIM-ery for names of1594 * remote branches, erroring out for invalid or ambiguous cases.1595 */1596if(argc && opts->accept_ref) {1597struct object_id rev;1598int dwim_ok =1599!opts->patch_mode &&1600 opts->dwim_new_local_branch &&1601 opts->track == BRANCH_TRACK_UNSPECIFIED &&1602!opts->new_branch;1603int n =parse_branchname_arg(argc, argv, dwim_ok,1604&new_branch_info, opts, &rev,1605&dwim_remotes_matched);1606 argv += n;1607 argc -= n;1608}else if(!opts->accept_ref && opts->from_treeish) {1609struct object_id rev;16101611if(get_oid_mb(opts->from_treeish, &rev))1612die(_("could not resolve%s"), opts->from_treeish);16131614setup_new_branch_info_and_source_tree(&new_branch_info,1615 opts, &rev,1616 opts->from_treeish);16171618if(!opts->source_tree)1619die(_("reference is not a tree:%s"), opts->from_treeish);1620}16211622if(opts->accept_pathspec && !opts->empty_pathspec_ok && !argc &&1623!opts->patch_mode)/* patch mode is special */1624die(_("you must specify path(s) to restore"));16251626if(argc) {1627parse_pathspec(&opts->pathspec,0,1628 opts->patch_mode ? PATHSPEC_PREFIX_ORIGIN :0,1629 prefix, argv);16301631if(!opts->pathspec.nr)1632die(_("invalid path specification"));16331634/*1635 * Try to give more helpful suggestion.1636 * new_branch && argc > 1 will be caught later.1637 */1638if(opts->new_branch && argc ==1)1639die(_("'%s' is not a commit and a branch '%s' cannot be created from it"),1640 argv[0], opts->new_branch);16411642if(opts->force_detach)1643die(_("git checkout: --detach does not take a path argument '%s'"),1644 argv[0]);16451646if(1< !!opts->writeout_stage + !!opts->force + !!opts->merge)1647die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\n"1648"checking out of the index."));1649}16501651if(opts->new_branch) {1652struct strbuf buf = STRBUF_INIT;16531654if(opts->new_branch_force)1655 opts->branch_exists =validate_branchname(opts->new_branch, &buf);1656else1657 opts->branch_exists =1658validate_new_branchname(opts->new_branch, &buf,0);1659strbuf_release(&buf);1660}16611662UNLEAK(opts);1663if(opts->patch_mode || opts->pathspec.nr) {1664int ret =checkout_paths(opts, new_branch_info.name);1665if(ret && dwim_remotes_matched >1&&1666 advice_checkout_ambiguous_remote_branch_name)1667advise(_("'%s' matched more than one remote tracking branch.\n"1668"We found%dremotes with a reference that matched. So we fell back\n"1669"on trying to resolve the argument as a path, but failed there too!\n"1670"\n"1671"If you meant to check out a remote tracking branch on, e.g. 'origin',\n"1672"you can do so by fully qualifying the name with the --track option:\n"1673"\n"1674" git checkout --track origin/<name>\n"1675"\n"1676"If you'd like to always have checkouts of an ambiguous <name> prefer\n"1677"one remote, e.g. the 'origin' remote, consider setting\n"1678"checkout.defaultRemote=origin in your config."),1679 argv[0],1680 dwim_remotes_matched);1681return ret;1682}else{1683returncheckout_branch(opts, &new_branch_info);1684}1685}16861687intcmd_checkout(int argc,const char**argv,const char*prefix)1688{1689struct checkout_opts opts;1690struct option *options;1691struct option checkout_options[] = {1692OPT_STRING('b', NULL, &opts.new_branch,N_("branch"),1693N_("create and checkout a new branch")),1694OPT_STRING('B', NULL, &opts.new_branch_force,N_("branch"),1695N_("create/reset and checkout a branch")),1696OPT_BOOL('l', NULL, &opts.new_branch_log,N_("create reflog for new branch")),1697OPT_BOOL(0,"guess", &opts.dwim_new_local_branch,1698N_("second guess 'git checkout <no-such-branch>' (default)")),1699OPT_BOOL(0,"overlay", &opts.overlay_mode,N_("use overlay mode (default)")),1700OPT_END()1701};1702int ret;17031704memset(&opts,0,sizeof(opts));1705 opts.dwim_new_local_branch =1;1706 opts.switch_branch_doing_nothing_is_ok =1;1707 opts.only_merge_on_switching_branches =0;1708 opts.accept_ref =1;1709 opts.accept_pathspec =1;1710 opts.implicit_detach =1;1711 opts.can_switch_when_in_progress =1;1712 opts.orphan_from_empty_tree =0;1713 opts.empty_pathspec_ok =1;1714 opts.overlay_mode = -1;1715 opts.checkout_index = -2;/* default on */1716 opts.checkout_worktree = -2;/* default on */17171718 options =parse_options_dup(checkout_options);1719 options =add_common_options(&opts, options);1720 options =add_common_switch_branch_options(&opts, options);1721 options =add_checkout_path_options(&opts, options);17221723 ret =checkout_main(argc, argv, prefix, &opts,1724 options, checkout_usage);1725FREE_AND_NULL(options);1726return ret;1727}17281729intcmd_switch(int argc,const char**argv,const char*prefix)1730{1731struct checkout_opts opts;1732struct option *options = NULL;1733struct option switch_options[] = {1734OPT_STRING('c',"create", &opts.new_branch,N_("branch"),1735N_("create and switch to a new branch")),1736OPT_STRING('C',"force-create", &opts.new_branch_force,N_("branch"),1737N_("create/reset and switch to a branch")),1738OPT_BOOL(0,"guess", &opts.dwim_new_local_branch,1739N_("second guess 'git switch <no-such-branch>'")),1740OPT_BOOL(0,"discard-changes", &opts.discard_changes,1741N_("throw away local modifications")),1742OPT_END()1743};1744int ret;17451746memset(&opts,0,sizeof(opts));1747 opts.dwim_new_local_branch =1;1748 opts.accept_ref =1;1749 opts.accept_pathspec =0;1750 opts.switch_branch_doing_nothing_is_ok =0;1751 opts.only_merge_on_switching_branches =1;1752 opts.implicit_detach =0;1753 opts.can_switch_when_in_progress =0;1754 opts.orphan_from_empty_tree =1;1755 opts.overlay_mode = -1;17561757 options =parse_options_dup(switch_options);1758 options =add_common_options(&opts, options);1759 options =add_common_switch_branch_options(&opts, options);17601761 ret =checkout_main(argc, argv, prefix, &opts,1762 options, switch_branch_usage);1763FREE_AND_NULL(options);1764return ret;1765}17661767intcmd_restore(int argc,const char**argv,const char*prefix)1768{1769struct checkout_opts opts;1770struct option *options;1771struct option restore_options[] = {1772OPT_STRING('s',"source", &opts.from_treeish,"<tree-ish>",1773N_("which tree-ish to checkout from")),1774OPT_BOOL('S',"staged", &opts.checkout_index,1775N_("restore the index")),1776OPT_BOOL('W',"worktree", &opts.checkout_worktree,1777N_("restore the working tree (default)")),1778OPT_BOOL(0,"ignore-unmerged", &opts.ignore_unmerged,1779N_("ignore unmerged entries")),1780OPT_BOOL(0,"overlay", &opts.overlay_mode,N_("use overlay mode")),1781OPT_END()1782};1783int ret;17841785memset(&opts,0,sizeof(opts));1786 opts.accept_ref =0;1787 opts.accept_pathspec =1;1788 opts.empty_pathspec_ok =0;1789 opts.overlay_mode =0;1790 opts.checkout_index = -1;/* default off */1791 opts.checkout_worktree = -2;/* default on */1792 opts.ignore_unmerged_opt ="--ignore-unmerged";17931794 options =parse_options_dup(restore_options);1795 options =add_common_options(&opts, options);1796 options =add_checkout_path_options(&opts, options);17971798 ret =checkout_main(argc, argv, prefix, &opts,1799 options, restore_usage);1800FREE_AND_NULL(options);1801return ret;1802}