1#include"builtin.h" 2#include"config.h" 3#include"lockfile.h" 4#include"parse-options.h" 5#include"refs.h" 6#include"commit.h" 7#include"tree.h" 8#include"tree-walk.h" 9#include"cache-tree.h" 10#include"unpack-trees.h" 11#include"dir.h" 12#include"run-command.h" 13#include"merge-recursive.h" 14#include"branch.h" 15#include"diff.h" 16#include"revision.h" 17#include"remote.h" 18#include"blob.h" 19#include"xdiff-interface.h" 20#include"ll-merge.h" 21#include"resolve-undo.h" 22#include"submodule-config.h" 23#include"submodule.h" 24 25static const char*const checkout_usage[] = { 26N_("git checkout [<options>] <branch>"), 27N_("git checkout [<options>] [<branch>] -- <file>..."), 28 NULL, 29}; 30 31struct checkout_opts { 32int patch_mode; 33int quiet; 34int merge; 35int force; 36int force_detach; 37int writeout_stage; 38int overwrite_ignore; 39int ignore_skipworktree; 40int ignore_other_worktrees; 41int show_progress; 42 43const char*new_branch; 44const char*new_branch_force; 45const char*new_orphan_branch; 46int new_branch_log; 47enum branch_track track; 48struct diff_options diff_options; 49 50int branch_exists; 51const char*prefix; 52struct pathspec pathspec; 53struct tree *source_tree; 54}; 55 56static intpost_checkout_hook(struct commit *old,struct commit *new, 57int changed) 58{ 59returnrun_hook_le(NULL,"post-checkout", 60oid_to_hex(old ? &old->object.oid : &null_oid), 61oid_to_hex(new? &new->object.oid : &null_oid), 62 changed ?"1":"0", NULL); 63/* "new" can be NULL when checking out from the index before 64 a commit exists. */ 65 66} 67 68static intupdate_some(const unsigned char*sha1,struct strbuf *base, 69const char*pathname,unsigned mode,int stage,void*context) 70{ 71int len; 72struct cache_entry *ce; 73int pos; 74 75if(S_ISDIR(mode)) 76return READ_TREE_RECURSIVE; 77 78 len = base->len +strlen(pathname); 79 ce =xcalloc(1,cache_entry_size(len)); 80hashcpy(ce->oid.hash, sha1); 81memcpy(ce->name, base->buf, base->len); 82memcpy(ce->name + base->len, pathname, len - base->len); 83 ce->ce_flags =create_ce_flags(0) | CE_UPDATE; 84 ce->ce_namelen = len; 85 ce->ce_mode =create_ce_mode(mode); 86 87/* 88 * If the entry is the same as the current index, we can leave the old 89 * entry in place. Whether it is UPTODATE or not, checkout_entry will 90 * do the right thing. 91 */ 92 pos =cache_name_pos(ce->name, ce->ce_namelen); 93if(pos >=0) { 94struct cache_entry *old = active_cache[pos]; 95if(ce->ce_mode == old->ce_mode && 96!oidcmp(&ce->oid, &old->oid)) { 97 old->ce_flags |= CE_UPDATE; 98free(ce); 99return0; 100} 101} 102 103add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE); 104return0; 105} 106 107static intread_tree_some(struct tree *tree,const struct pathspec *pathspec) 108{ 109read_tree_recursive(tree,"",0,0, pathspec, update_some, NULL); 110 111/* update the index with the given tree's info 112 * for all args, expanding wildcards, and exit 113 * with any non-zero return code. 114 */ 115return0; 116} 117 118static intskip_same_name(const struct cache_entry *ce,int pos) 119{ 120while(++pos < active_nr && 121!strcmp(active_cache[pos]->name, ce->name)) 122;/* skip */ 123return pos; 124} 125 126static intcheck_stage(int stage,const struct cache_entry *ce,int pos) 127{ 128while(pos < active_nr && 129!strcmp(active_cache[pos]->name, ce->name)) { 130if(ce_stage(active_cache[pos]) == stage) 131return0; 132 pos++; 133} 134if(stage ==2) 135returnerror(_("path '%s' does not have our version"), ce->name); 136else 137returnerror(_("path '%s' does not have their version"), ce->name); 138} 139 140static intcheck_stages(unsigned stages,const struct cache_entry *ce,int pos) 141{ 142unsigned seen =0; 143const char*name = ce->name; 144 145while(pos < active_nr) { 146 ce = active_cache[pos]; 147if(strcmp(name, ce->name)) 148break; 149 seen |= (1<<ce_stage(ce)); 150 pos++; 151} 152if((stages & seen) != stages) 153returnerror(_("path '%s' does not have all necessary versions"), 154 name); 155return0; 156} 157 158static intcheckout_stage(int stage,const struct cache_entry *ce,int pos, 159const struct checkout *state) 160{ 161while(pos < active_nr && 162!strcmp(active_cache[pos]->name, ce->name)) { 163if(ce_stage(active_cache[pos]) == stage) 164returncheckout_entry(active_cache[pos], state, NULL); 165 pos++; 166} 167if(stage ==2) 168returnerror(_("path '%s' does not have our version"), ce->name); 169else 170returnerror(_("path '%s' does not have their version"), ce->name); 171} 172 173static intcheckout_merged(int pos,const struct checkout *state) 174{ 175struct cache_entry *ce = active_cache[pos]; 176const char*path = ce->name; 177 mmfile_t ancestor, ours, theirs; 178int status; 179struct object_id oid; 180 mmbuffer_t result_buf; 181struct object_id threeway[3]; 182unsigned mode =0; 183 184memset(threeway,0,sizeof(threeway)); 185while(pos < active_nr) { 186int stage; 187 stage =ce_stage(ce); 188if(!stage ||strcmp(path, ce->name)) 189break; 190oidcpy(&threeway[stage -1], &ce->oid); 191if(stage ==2) 192 mode =create_ce_mode(ce->ce_mode); 193 pos++; 194 ce = active_cache[pos]; 195} 196if(is_null_oid(&threeway[1]) ||is_null_oid(&threeway[2])) 197returnerror(_("path '%s' does not have necessary versions"), path); 198 199read_mmblob(&ancestor, &threeway[0]); 200read_mmblob(&ours, &threeway[1]); 201read_mmblob(&theirs, &threeway[2]); 202 203/* 204 * NEEDSWORK: re-create conflicts from merges with 205 * merge.renormalize set, too 206 */ 207 status =ll_merge(&result_buf, path, &ancestor,"base", 208&ours,"ours", &theirs,"theirs", NULL); 209free(ancestor.ptr); 210free(ours.ptr); 211free(theirs.ptr); 212if(status <0|| !result_buf.ptr) { 213free(result_buf.ptr); 214returnerror(_("path '%s': cannot merge"), path); 215} 216 217/* 218 * NEEDSWORK: 219 * There is absolutely no reason to write this as a blob object 220 * and create a phony cache entry. This hack is primarily to get 221 * to the write_entry() machinery that massages the contents to 222 * work-tree format and writes out which only allows it for a 223 * cache entry. The code in write_entry() needs to be refactored 224 * to allow us to feed a <buffer, size, mode> instead of a cache 225 * entry. Such a refactoring would help merge_recursive as well 226 * (it also writes the merge result to the object database even 227 * when it may contain conflicts). 228 */ 229if(write_sha1_file(result_buf.ptr, result_buf.size, 230 blob_type, oid.hash)) 231die(_("Unable to add merge result for '%s'"), path); 232free(result_buf.ptr); 233 ce =make_cache_entry(mode, oid.hash, path,2,0); 234if(!ce) 235die(_("make_cache_entry failed for path '%s'"), path); 236 status =checkout_entry(ce, state, NULL); 237free(ce); 238return status; 239} 240 241static intcheckout_paths(const struct checkout_opts *opts, 242const char*revision) 243{ 244int pos; 245struct checkout state = CHECKOUT_INIT; 246static char*ps_matched; 247struct object_id rev; 248struct commit *head; 249int errs =0; 250struct lock_file *lock_file; 251 252if(opts->track != BRANCH_TRACK_UNSPECIFIED) 253die(_("'%s' cannot be used with updating paths"),"--track"); 254 255if(opts->new_branch_log) 256die(_("'%s' cannot be used with updating paths"),"-l"); 257 258if(opts->force && opts->patch_mode) 259die(_("'%s' cannot be used with updating paths"),"-f"); 260 261if(opts->force_detach) 262die(_("'%s' cannot be used with updating paths"),"--detach"); 263 264if(opts->merge && opts->patch_mode) 265die(_("'%s' cannot be used with%s"),"--merge","--patch"); 266 267if(opts->force && opts->merge) 268die(_("'%s' cannot be used with%s"),"-f","-m"); 269 270if(opts->new_branch) 271die(_("Cannot update paths and switch to branch '%s' at the same time."), 272 opts->new_branch); 273 274if(opts->patch_mode) 275returnrun_add_interactive(revision,"--patch=checkout", 276&opts->pathspec); 277 278 lock_file =xcalloc(1,sizeof(struct lock_file)); 279 280hold_locked_index(lock_file, LOCK_DIE_ON_ERROR); 281if(read_cache_preload(&opts->pathspec) <0) 282returnerror(_("index file corrupt")); 283 284if(opts->source_tree) 285read_tree_some(opts->source_tree, &opts->pathspec); 286 287 ps_matched =xcalloc(opts->pathspec.nr,1); 288 289/* 290 * Make sure all pathspecs participated in locating the paths 291 * to be checked out. 292 */ 293for(pos =0; pos < active_nr; pos++) { 294struct cache_entry *ce = active_cache[pos]; 295 ce->ce_flags &= ~CE_MATCHED; 296if(!opts->ignore_skipworktree &&ce_skip_worktree(ce)) 297continue; 298if(opts->source_tree && !(ce->ce_flags & CE_UPDATE)) 299/* 300 * "git checkout tree-ish -- path", but this entry 301 * is in the original index; it will not be checked 302 * out to the working tree and it does not matter 303 * if pathspec matched this entry. We will not do 304 * anything to this entry at all. 305 */ 306continue; 307/* 308 * Either this entry came from the tree-ish we are 309 * checking the paths out of, or we are checking out 310 * of the index. 311 * 312 * If it comes from the tree-ish, we already know it 313 * matches the pathspec and could just stamp 314 * CE_MATCHED to it from update_some(). But we still 315 * need ps_matched and read_tree_recursive (and 316 * eventually tree_entry_interesting) cannot fill 317 * ps_matched yet. Once it can, we can avoid calling 318 * match_pathspec() for _all_ entries when 319 * opts->source_tree != NULL. 320 */ 321if(ce_path_match(ce, &opts->pathspec, ps_matched)) 322 ce->ce_flags |= CE_MATCHED; 323} 324 325if(report_path_error(ps_matched, &opts->pathspec, opts->prefix)) { 326free(ps_matched); 327return1; 328} 329free(ps_matched); 330 331/* "checkout -m path" to recreate conflicted state */ 332if(opts->merge) 333unmerge_marked_index(&the_index); 334 335/* Any unmerged paths? */ 336for(pos =0; pos < active_nr; pos++) { 337const struct cache_entry *ce = active_cache[pos]; 338if(ce->ce_flags & CE_MATCHED) { 339if(!ce_stage(ce)) 340continue; 341if(opts->force) { 342warning(_("path '%s' is unmerged"), ce->name); 343}else if(opts->writeout_stage) { 344 errs |=check_stage(opts->writeout_stage, ce, pos); 345}else if(opts->merge) { 346 errs |=check_stages((1<<2) | (1<<3), ce, pos); 347}else{ 348 errs =1; 349error(_("path '%s' is unmerged"), ce->name); 350} 351 pos =skip_same_name(ce, pos) -1; 352} 353} 354if(errs) 355return1; 356 357/* Now we are committed to check them out */ 358 state.force =1; 359 state.refresh_cache =1; 360 state.istate = &the_index; 361 362enable_delayed_checkout(&state); 363for(pos =0; pos < active_nr; pos++) { 364struct cache_entry *ce = active_cache[pos]; 365if(ce->ce_flags & CE_MATCHED) { 366if(!ce_stage(ce)) { 367 errs |=checkout_entry(ce, &state, NULL); 368continue; 369} 370if(opts->writeout_stage) 371 errs |=checkout_stage(opts->writeout_stage, ce, pos, &state); 372else if(opts->merge) 373 errs |=checkout_merged(pos, &state); 374 pos =skip_same_name(ce, pos) -1; 375} 376} 377 errs |=finish_delayed_checkout(&state); 378 379if(write_locked_index(&the_index, lock_file, COMMIT_LOCK)) 380die(_("unable to write new index file")); 381 382read_ref_full("HEAD",0, rev.hash, NULL); 383 head =lookup_commit_reference_gently(&rev,1); 384 385 errs |=post_checkout_hook(head, head,0); 386return errs; 387} 388 389static voidshow_local_changes(struct object *head, 390const struct diff_options *opts) 391{ 392struct rev_info rev; 393/* I think we want full paths, even if we're in a subdirectory. */ 394init_revisions(&rev, NULL); 395 rev.diffopt.flags = opts->flags; 396 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS; 397diff_setup_done(&rev.diffopt); 398add_pending_object(&rev, head, NULL); 399run_diff_index(&rev,0); 400} 401 402static voiddescribe_detached_head(const char*msg,struct commit *commit) 403{ 404struct strbuf sb = STRBUF_INIT; 405if(!parse_commit(commit)) 406pp_commit_easy(CMIT_FMT_ONELINE, commit, &sb); 407fprintf(stderr,"%s %s...%s\n", msg, 408find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV), sb.buf); 409strbuf_release(&sb); 410} 411 412static intreset_tree(struct tree *tree,const struct checkout_opts *o, 413int worktree,int*writeout_error) 414{ 415struct unpack_trees_options opts; 416struct tree_desc tree_desc; 417 418memset(&opts,0,sizeof(opts)); 419 opts.head_idx = -1; 420 opts.update = worktree; 421 opts.skip_unmerged = !worktree; 422 opts.reset =1; 423 opts.merge =1; 424 opts.fn = oneway_merge; 425 opts.verbose_update = o->show_progress; 426 opts.src_index = &the_index; 427 opts.dst_index = &the_index; 428parse_tree(tree); 429init_tree_desc(&tree_desc, tree->buffer, tree->size); 430switch(unpack_trees(1, &tree_desc, &opts)) { 431case-2: 432*writeout_error =1; 433/* 434 * We return 0 nevertheless, as the index is all right 435 * and more importantly we have made best efforts to 436 * update paths in the work tree, and we cannot revert 437 * them. 438 */ 439/* fallthrough */ 440case0: 441return0; 442default: 443return128; 444} 445} 446 447struct branch_info { 448const char*name;/* The short name used */ 449const char*path;/* The full name of a real branch */ 450struct commit *commit;/* The named commit */ 451/* 452 * if not null the branch is detached because it's already 453 * checked out in this checkout 454 */ 455char*checkout; 456}; 457 458static voidsetup_branch_path(struct branch_info *branch) 459{ 460struct strbuf buf = STRBUF_INIT; 461 462strbuf_branchname(&buf, branch->name, INTERPRET_BRANCH_LOCAL); 463if(strcmp(buf.buf, branch->name)) 464 branch->name =xstrdup(buf.buf); 465strbuf_splice(&buf,0,0,"refs/heads/",11); 466 branch->path =strbuf_detach(&buf, NULL); 467} 468 469static intmerge_working_tree(const struct checkout_opts *opts, 470struct branch_info *old, 471struct branch_info *new, 472int*writeout_error) 473{ 474int ret; 475struct lock_file *lock_file =xcalloc(1,sizeof(struct lock_file)); 476 477hold_locked_index(lock_file, LOCK_DIE_ON_ERROR); 478if(read_cache_preload(NULL) <0) 479returnerror(_("index file corrupt")); 480 481resolve_undo_clear(); 482if(opts->force) { 483 ret =reset_tree(new->commit->tree, opts,1, writeout_error); 484if(ret) 485return ret; 486}else{ 487struct tree_desc trees[2]; 488struct tree *tree; 489struct unpack_trees_options topts; 490 491memset(&topts,0,sizeof(topts)); 492 topts.head_idx = -1; 493 topts.src_index = &the_index; 494 topts.dst_index = &the_index; 495 496setup_unpack_trees_porcelain(&topts,"checkout"); 497 498refresh_cache(REFRESH_QUIET); 499 500if(unmerged_cache()) { 501error(_("you need to resolve your current index first")); 502return1; 503} 504 505/* 2-way merge to the new branch */ 506 topts.initial_checkout =is_cache_unborn(); 507 topts.update =1; 508 topts.merge =1; 509 topts.gently = opts->merge && old->commit; 510 topts.verbose_update = opts->show_progress; 511 topts.fn = twoway_merge; 512if(opts->overwrite_ignore) { 513 topts.dir =xcalloc(1,sizeof(*topts.dir)); 514 topts.dir->flags |= DIR_SHOW_IGNORED; 515setup_standard_excludes(topts.dir); 516} 517 tree =parse_tree_indirect(old->commit ? 518&old->commit->object.oid : 519&empty_tree_oid); 520init_tree_desc(&trees[0], tree->buffer, tree->size); 521 tree =parse_tree_indirect(&new->commit->object.oid); 522init_tree_desc(&trees[1], tree->buffer, tree->size); 523 524 ret =unpack_trees(2, trees, &topts); 525if(ret == -1) { 526/* 527 * Unpack couldn't do a trivial merge; either 528 * give up or do a real merge, depending on 529 * whether the merge flag was used. 530 */ 531struct tree *result; 532struct tree *work; 533struct merge_options o; 534if(!opts->merge) 535return1; 536 537/* 538 * Without old->commit, the below is the same as 539 * the two-tree unpack we already tried and failed. 540 */ 541if(!old->commit) 542return1; 543 544/* Do more real merge */ 545 546/* 547 * We update the index fully, then write the 548 * tree from the index, then merge the new 549 * branch with the current tree, with the old 550 * branch as the base. Then we reset the index 551 * (but not the working tree) to the new 552 * branch, leaving the working tree as the 553 * merged version, but skipping unmerged 554 * entries in the index. 555 */ 556 557add_files_to_cache(NULL, NULL,0); 558/* 559 * NEEDSWORK: carrying over local changes 560 * when branches have different end-of-line 561 * normalization (or clean+smudge rules) is 562 * a pain; plumb in an option to set 563 * o.renormalize? 564 */ 565init_merge_options(&o); 566 o.verbosity =0; 567 work =write_tree_from_memory(&o); 568 569 ret =reset_tree(new->commit->tree, opts,1, 570 writeout_error); 571if(ret) 572return ret; 573 o.ancestor = old->name; 574 o.branch1 =new->name; 575 o.branch2 ="local"; 576 ret =merge_trees(&o,new->commit->tree, work, 577 old->commit->tree, &result); 578if(ret <0) 579exit(128); 580 ret =reset_tree(new->commit->tree, opts,0, 581 writeout_error); 582strbuf_release(&o.obuf); 583if(ret) 584return ret; 585} 586} 587 588if(!active_cache_tree) 589 active_cache_tree =cache_tree(); 590 591if(!cache_tree_fully_valid(active_cache_tree)) 592cache_tree_update(&the_index, WRITE_TREE_SILENT | WRITE_TREE_REPAIR); 593 594if(write_locked_index(&the_index, lock_file, COMMIT_LOCK)) 595die(_("unable to write new index file")); 596 597if(!opts->force && !opts->quiet) 598show_local_changes(&new->commit->object, &opts->diff_options); 599 600return0; 601} 602 603static voidreport_tracking(struct branch_info *new) 604{ 605struct strbuf sb = STRBUF_INIT; 606struct branch *branch =branch_get(new->name); 607 608if(!format_tracking_info(branch, &sb)) 609return; 610fputs(sb.buf, stdout); 611strbuf_release(&sb); 612} 613 614static voidupdate_refs_for_switch(const struct checkout_opts *opts, 615struct branch_info *old, 616struct branch_info *new) 617{ 618struct strbuf msg = STRBUF_INIT; 619const char*old_desc, *reflog_msg; 620if(opts->new_branch) { 621if(opts->new_orphan_branch) { 622char*refname; 623 624 refname =mkpathdup("refs/heads/%s", opts->new_orphan_branch); 625if(opts->new_branch_log && 626!should_autocreate_reflog(refname)) { 627int ret; 628struct strbuf err = STRBUF_INIT; 629 630 ret =safe_create_reflog(refname,1, &err); 631if(ret) { 632fprintf(stderr,_("Can not do reflog for '%s':%s\n"), 633 opts->new_orphan_branch, err.buf); 634strbuf_release(&err); 635free(refname); 636return; 637} 638strbuf_release(&err); 639} 640free(refname); 641} 642else 643create_branch(opts->new_branch,new->name, 644 opts->new_branch_force ?1:0, 645 opts->new_branch_log, 646 opts->new_branch_force ?1:0, 647 opts->quiet, 648 opts->track); 649new->name = opts->new_branch; 650setup_branch_path(new); 651} 652 653 old_desc = old->name; 654if(!old_desc && old->commit) 655 old_desc =oid_to_hex(&old->commit->object.oid); 656 657 reflog_msg =getenv("GIT_REFLOG_ACTION"); 658if(!reflog_msg) 659strbuf_addf(&msg,"checkout: moving from%sto%s", 660 old_desc ? old_desc :"(invalid)",new->name); 661else 662strbuf_insert(&msg,0, reflog_msg,strlen(reflog_msg)); 663 664if(!strcmp(new->name,"HEAD") && !new->path && !opts->force_detach) { 665/* Nothing to do. */ 666}else if(opts->force_detach || !new->path) {/* No longer on any branch. */ 667update_ref(msg.buf,"HEAD",new->commit->object.oid.hash, NULL, 668 REF_NODEREF, UPDATE_REFS_DIE_ON_ERR); 669if(!opts->quiet) { 670if(old->path && 671 advice_detached_head && !opts->force_detach) 672detach_advice(new->name); 673describe_detached_head(_("HEAD is now at"),new->commit); 674} 675}else if(new->path) {/* Switch branches. */ 676if(create_symref("HEAD",new->path, msg.buf) <0) 677die(_("unable to update HEAD")); 678if(!opts->quiet) { 679if(old->path && !strcmp(new->path, old->path)) { 680if(opts->new_branch_force) 681fprintf(stderr,_("Reset branch '%s'\n"), 682new->name); 683else 684fprintf(stderr,_("Already on '%s'\n"), 685new->name); 686}else if(opts->new_branch) { 687if(opts->branch_exists) 688fprintf(stderr,_("Switched to and reset branch '%s'\n"),new->name); 689else 690fprintf(stderr,_("Switched to a new branch '%s'\n"),new->name); 691}else{ 692fprintf(stderr,_("Switched to branch '%s'\n"), 693new->name); 694} 695} 696if(old->path && old->name) { 697if(!ref_exists(old->path) &&reflog_exists(old->path)) 698delete_reflog(old->path); 699} 700} 701remove_branch_state(); 702strbuf_release(&msg); 703if(!opts->quiet && 704(new->path || (!opts->force_detach && !strcmp(new->name,"HEAD")))) 705report_tracking(new); 706} 707 708static intadd_pending_uninteresting_ref(const char*refname, 709const struct object_id *oid, 710int flags,void*cb_data) 711{ 712add_pending_oid(cb_data, refname, oid, UNINTERESTING); 713return0; 714} 715 716static voiddescribe_one_orphan(struct strbuf *sb,struct commit *commit) 717{ 718strbuf_addstr(sb," "); 719strbuf_add_unique_abbrev(sb, commit->object.oid.hash, DEFAULT_ABBREV); 720strbuf_addch(sb,' '); 721if(!parse_commit(commit)) 722pp_commit_easy(CMIT_FMT_ONELINE, commit, sb); 723strbuf_addch(sb,'\n'); 724} 725 726#define ORPHAN_CUTOFF 4 727static voidsuggest_reattach(struct commit *commit,struct rev_info *revs) 728{ 729struct commit *c, *last = NULL; 730struct strbuf sb = STRBUF_INIT; 731int lost =0; 732while((c =get_revision(revs)) != NULL) { 733if(lost < ORPHAN_CUTOFF) 734describe_one_orphan(&sb, c); 735 last = c; 736 lost++; 737} 738if(ORPHAN_CUTOFF < lost) { 739int more = lost - ORPHAN_CUTOFF; 740if(more ==1) 741describe_one_orphan(&sb, last); 742else 743strbuf_addf(&sb,_(" ... and%dmore.\n"), more); 744} 745 746fprintf(stderr, 747Q_( 748/* The singular version */ 749"Warning: you are leaving%dcommit behind, " 750"not connected to\n" 751"any of your branches:\n\n" 752"%s\n", 753/* The plural version */ 754"Warning: you are leaving%dcommits behind, " 755"not connected to\n" 756"any of your branches:\n\n" 757"%s\n", 758/* Give ngettext() the count */ 759 lost), 760 lost, 761 sb.buf); 762strbuf_release(&sb); 763 764if(advice_detached_head) 765fprintf(stderr, 766Q_( 767/* The singular version */ 768"If you want to keep it by creating a new branch, " 769"this may be a good time\nto do so with:\n\n" 770" git branch <new-branch-name>%s\n\n", 771/* The plural version */ 772"If you want to keep them by creating a new branch, " 773"this may be a good time\nto do so with:\n\n" 774" git branch <new-branch-name>%s\n\n", 775/* Give ngettext() the count */ 776 lost), 777find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV)); 778} 779 780/* 781 * We are about to leave commit that was at the tip of a detached 782 * HEAD. If it is not reachable from any ref, this is the last chance 783 * for the user to do so without resorting to reflog. 784 */ 785static voidorphaned_commit_warning(struct commit *old,struct commit *new) 786{ 787struct rev_info revs; 788struct object *object = &old->object; 789 790init_revisions(&revs, NULL); 791setup_revisions(0, NULL, &revs, NULL); 792 793 object->flags &= ~UNINTERESTING; 794add_pending_object(&revs, object,oid_to_hex(&object->oid)); 795 796for_each_ref(add_pending_uninteresting_ref, &revs); 797add_pending_oid(&revs,"HEAD", &new->object.oid, UNINTERESTING); 798 799if(prepare_revision_walk(&revs)) 800die(_("internal error in revision walk")); 801if(!(old->object.flags & UNINTERESTING)) 802suggest_reattach(old, &revs); 803else 804describe_detached_head(_("Previous HEAD position was"), old); 805 806/* Clean up objects used, as they will be reused. */ 807clear_commit_marks_all(ALL_REV_FLAGS); 808} 809 810static intswitch_branches(const struct checkout_opts *opts, 811struct branch_info *new) 812{ 813int ret =0; 814struct branch_info old; 815void*path_to_free; 816struct object_id rev; 817int flag, writeout_error =0; 818memset(&old,0,sizeof(old)); 819 old.path = path_to_free =resolve_refdup("HEAD",0, rev.hash, &flag); 820if(old.path) 821 old.commit =lookup_commit_reference_gently(&rev,1); 822if(!(flag & REF_ISSYMREF)) 823 old.path = NULL; 824 825if(old.path) 826skip_prefix(old.path,"refs/heads/", &old.name); 827 828if(!new->name) { 829new->name ="HEAD"; 830new->commit = old.commit; 831if(!new->commit) 832die(_("You are on a branch yet to be born")); 833parse_commit_or_die(new->commit); 834} 835 836 ret =merge_working_tree(opts, &old,new, &writeout_error); 837if(ret) { 838free(path_to_free); 839return ret; 840} 841 842if(!opts->quiet && !old.path && old.commit &&new->commit != old.commit) 843orphaned_commit_warning(old.commit,new->commit); 844 845update_refs_for_switch(opts, &old,new); 846 847 ret =post_checkout_hook(old.commit,new->commit,1); 848free(path_to_free); 849return ret || writeout_error; 850} 851 852static intgit_checkout_config(const char*var,const char*value,void*cb) 853{ 854if(!strcmp(var,"diff.ignoresubmodules")) { 855struct checkout_opts *opts = cb; 856handle_ignore_submodules_arg(&opts->diff_options, value); 857return0; 858} 859 860if(starts_with(var,"submodule.")) 861returngit_default_submodule_config(var, value, NULL); 862 863returngit_xmerge_config(var, value, NULL); 864} 865 866struct tracking_name_data { 867/* const */char*src_ref; 868char*dst_ref; 869struct object_id *dst_oid; 870int unique; 871}; 872 873static intcheck_tracking_name(struct remote *remote,void*cb_data) 874{ 875struct tracking_name_data *cb = cb_data; 876struct refspec query; 877memset(&query,0,sizeof(struct refspec)); 878 query.src = cb->src_ref; 879if(remote_find_tracking(remote, &query) || 880get_oid(query.dst, cb->dst_oid)) { 881free(query.dst); 882return0; 883} 884if(cb->dst_ref) { 885free(query.dst); 886 cb->unique =0; 887return0; 888} 889 cb->dst_ref = query.dst; 890return0; 891} 892 893static const char*unique_tracking_name(const char*name,struct object_id *oid) 894{ 895struct tracking_name_data cb_data = { NULL, NULL, NULL,1}; 896 cb_data.src_ref =xstrfmt("refs/heads/%s", name); 897 cb_data.dst_oid = oid; 898for_each_remote(check_tracking_name, &cb_data); 899free(cb_data.src_ref); 900if(cb_data.unique) 901return cb_data.dst_ref; 902free(cb_data.dst_ref); 903return NULL; 904} 905 906static intparse_branchname_arg(int argc,const char**argv, 907int dwim_new_local_branch_ok, 908struct branch_info *new, 909struct checkout_opts *opts, 910struct object_id *rev) 911{ 912struct tree **source_tree = &opts->source_tree; 913const char**new_branch = &opts->new_branch; 914int argcount =0; 915struct object_id branch_rev; 916const char*arg; 917int dash_dash_pos; 918int has_dash_dash =0; 919int i; 920 921/* 922 * case 1: git checkout <ref> -- [<paths>] 923 * 924 * <ref> must be a valid tree, everything after the '--' must be 925 * a path. 926 * 927 * case 2: git checkout -- [<paths>] 928 * 929 * everything after the '--' must be paths. 930 * 931 * case 3: git checkout <something> [--] 932 * 933 * (a) If <something> is a commit, that is to 934 * switch to the branch or detach HEAD at it. As a special case, 935 * if <something> is A...B (missing A or B means HEAD but you can 936 * omit at most one side), and if there is a unique merge base 937 * between A and B, A...B names that merge base. 938 * 939 * (b) If <something> is _not_ a commit, either "--" is present 940 * or <something> is not a path, no -t or -b was given, and 941 * and there is a tracking branch whose name is <something> 942 * in one and only one remote, then this is a short-hand to 943 * fork local <something> from that remote-tracking branch. 944 * 945 * (c) Otherwise, if "--" is present, treat it like case (1). 946 * 947 * (d) Otherwise : 948 * - if it's a reference, treat it like case (1) 949 * - else if it's a path, treat it like case (2) 950 * - else: fail. 951 * 952 * case 4: git checkout <something> <paths> 953 * 954 * The first argument must not be ambiguous. 955 * - If it's *only* a reference, treat it like case (1). 956 * - If it's only a path, treat it like case (2). 957 * - else: fail. 958 * 959 */ 960if(!argc) 961return0; 962 963 arg = argv[0]; 964 dash_dash_pos = -1; 965for(i =0; i < argc; i++) { 966if(!strcmp(argv[i],"--")) { 967 dash_dash_pos = i; 968break; 969} 970} 971if(dash_dash_pos ==0) 972return1;/* case (2) */ 973else if(dash_dash_pos ==1) 974 has_dash_dash =1;/* case (3) or (1) */ 975else if(dash_dash_pos >=2) 976die(_("only one reference expected,%dgiven."), dash_dash_pos); 977 978if(!strcmp(arg,"-")) 979 arg ="@{-1}"; 980 981if(get_oid_mb(arg, rev)) { 982/* 983 * Either case (3) or (4), with <something> not being 984 * a commit, or an attempt to use case (1) with an 985 * invalid ref. 986 * 987 * It's likely an error, but we need to find out if 988 * we should auto-create the branch, case (3).(b). 989 */ 990int recover_with_dwim = dwim_new_local_branch_ok; 991 992if(!has_dash_dash && 993(check_filename(opts->prefix, arg) || !no_wildcard(arg))) 994 recover_with_dwim =0; 995/* 996 * Accept "git checkout foo" and "git checkout foo --" 997 * as candidates for dwim. 998 */ 999if(!(argc ==1&& !has_dash_dash) &&1000!(argc ==2&& has_dash_dash))1001 recover_with_dwim =0;10021003if(recover_with_dwim) {1004const char*remote =unique_tracking_name(arg, rev);1005if(remote) {1006*new_branch = arg;1007 arg = remote;1008/* DWIMmed to create local branch, case (3).(b) */1009}else{1010 recover_with_dwim =0;1011}1012}10131014if(!recover_with_dwim) {1015if(has_dash_dash)1016die(_("invalid reference:%s"), arg);1017return argcount;1018}1019}10201021/* we can't end up being in (2) anymore, eat the argument */1022 argcount++;1023 argv++;1024 argc--;10251026new->name = arg;1027setup_branch_path(new);10281029if(!check_refname_format(new->path,0) &&1030!read_ref(new->path, branch_rev.hash))1031oidcpy(rev, &branch_rev);1032else1033new->path = NULL;/* not an existing branch */10341035new->commit =lookup_commit_reference_gently(rev,1);1036if(!new->commit) {1037/* not a commit */1038*source_tree =parse_tree_indirect(rev);1039}else{1040parse_commit_or_die(new->commit);1041*source_tree =new->commit->tree;1042}10431044if(!*source_tree)/* case (1): want a tree */1045die(_("reference is not a tree:%s"), arg);1046if(!has_dash_dash) {/* case (3).(d) -> (1) */1047/*1048 * Do not complain the most common case1049 * git checkout branch1050 * even if there happen to be a file called 'branch';1051 * it would be extremely annoying.1052 */1053if(argc)1054verify_non_filename(opts->prefix, arg);1055}else{1056 argcount++;1057 argv++;1058 argc--;1059}10601061return argcount;1062}10631064static intswitch_unborn_to_new_branch(const struct checkout_opts *opts)1065{1066int status;1067struct strbuf branch_ref = STRBUF_INIT;10681069if(!opts->new_branch)1070die(_("You are on a branch yet to be born"));1071strbuf_addf(&branch_ref,"refs/heads/%s", opts->new_branch);1072 status =create_symref("HEAD", branch_ref.buf,"checkout -b");1073strbuf_release(&branch_ref);1074if(!opts->quiet)1075fprintf(stderr,_("Switched to a new branch '%s'\n"),1076 opts->new_branch);1077return status;1078}10791080static intcheckout_branch(struct checkout_opts *opts,1081struct branch_info *new)1082{1083if(opts->pathspec.nr)1084die(_("paths cannot be used with switching branches"));10851086if(opts->patch_mode)1087die(_("'%s' cannot be used with switching branches"),1088"--patch");10891090if(opts->writeout_stage)1091die(_("'%s' cannot be used with switching branches"),1092"--ours/--theirs");10931094if(opts->force && opts->merge)1095die(_("'%s' cannot be used with '%s'"),"-f","-m");10961097if(opts->force_detach && opts->new_branch)1098die(_("'%s' cannot be used with '%s'"),1099"--detach","-b/-B/--orphan");11001101if(opts->new_orphan_branch) {1102if(opts->track != BRANCH_TRACK_UNSPECIFIED)1103die(_("'%s' cannot be used with '%s'"),"--orphan","-t");1104}else if(opts->force_detach) {1105if(opts->track != BRANCH_TRACK_UNSPECIFIED)1106die(_("'%s' cannot be used with '%s'"),"--detach","-t");1107}else if(opts->track == BRANCH_TRACK_UNSPECIFIED)1108 opts->track = git_branch_track;11091110if(new->name && !new->commit)1111die(_("Cannot switch branch to a non-commit '%s'"),1112new->name);11131114if(new->path && !opts->force_detach && !opts->new_branch &&1115!opts->ignore_other_worktrees) {1116int flag;1117char*head_ref =resolve_refdup("HEAD",0, NULL, &flag);1118if(head_ref &&1119(!(flag & REF_ISSYMREF) ||strcmp(head_ref,new->path)))1120die_if_checked_out(new->path,1);1121free(head_ref);1122}11231124if(!new->commit && opts->new_branch) {1125struct object_id rev;1126int flag;11271128if(!read_ref_full("HEAD",0, rev.hash, &flag) &&1129(flag & REF_ISSYMREF) &&is_null_oid(&rev))1130returnswitch_unborn_to_new_branch(opts);1131}1132returnswitch_branches(opts,new);1133}11341135intcmd_checkout(int argc,const char**argv,const char*prefix)1136{1137struct checkout_opts opts;1138struct branch_info new;1139char*conflict_style = NULL;1140int dwim_new_local_branch =1;1141struct option options[] = {1142OPT__QUIET(&opts.quiet,N_("suppress progress reporting")),1143OPT_STRING('b', NULL, &opts.new_branch,N_("branch"),1144N_("create and checkout a new branch")),1145OPT_STRING('B', NULL, &opts.new_branch_force,N_("branch"),1146N_("create/reset and checkout a branch")),1147OPT_BOOL('l', NULL, &opts.new_branch_log,N_("create reflog for new branch")),1148OPT_BOOL(0,"detach", &opts.force_detach,N_("detach HEAD at named commit")),1149OPT_SET_INT('t',"track", &opts.track,N_("set upstream info for new branch"),1150 BRANCH_TRACK_EXPLICIT),1151OPT_STRING(0,"orphan", &opts.new_orphan_branch,N_("new-branch"),N_("new unparented branch")),1152OPT_SET_INT('2',"ours", &opts.writeout_stage,N_("checkout our version for unmerged files"),11532),1154OPT_SET_INT('3',"theirs", &opts.writeout_stage,N_("checkout their version for unmerged files"),11553),1156OPT__FORCE(&opts.force,N_("force checkout (throw away local modifications)")),1157OPT_BOOL('m',"merge", &opts.merge,N_("perform a 3-way merge with the new branch")),1158OPT_BOOL(0,"overwrite-ignore", &opts.overwrite_ignore,N_("update ignored files (default)")),1159OPT_STRING(0,"conflict", &conflict_style,N_("style"),1160N_("conflict style (merge or diff3)")),1161OPT_BOOL('p',"patch", &opts.patch_mode,N_("select hunks interactively")),1162OPT_BOOL(0,"ignore-skip-worktree-bits", &opts.ignore_skipworktree,1163N_("do not limit pathspecs to sparse entries only")),1164OPT_HIDDEN_BOOL(0,"guess", &dwim_new_local_branch,1165N_("second guess 'git checkout <no-such-branch>'")),1166OPT_BOOL(0,"ignore-other-worktrees", &opts.ignore_other_worktrees,1167N_("do not check if another worktree is holding the given ref")),1168{ OPTION_CALLBACK,0,"recurse-submodules", NULL,1169"checkout","control recursive updating of submodules",1170 PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater },1171OPT_BOOL(0,"progress", &opts.show_progress,N_("force progress reporting")),1172OPT_END(),1173};11741175memset(&opts,0,sizeof(opts));1176memset(&new,0,sizeof(new));1177 opts.overwrite_ignore =1;1178 opts.prefix = prefix;1179 opts.show_progress = -1;11801181git_config(git_checkout_config, &opts);11821183 opts.track = BRANCH_TRACK_UNSPECIFIED;11841185 argc =parse_options(argc, argv, prefix, options, checkout_usage,1186 PARSE_OPT_KEEP_DASHDASH);11871188if(opts.show_progress <0) {1189if(opts.quiet)1190 opts.show_progress =0;1191else1192 opts.show_progress =isatty(2);1193}11941195if(conflict_style) {1196 opts.merge =1;/* implied */1197git_xmerge_config("merge.conflictstyle", conflict_style, NULL);1198}11991200if((!!opts.new_branch + !!opts.new_branch_force + !!opts.new_orphan_branch) >1)1201die(_("-b, -B and --orphan are mutually exclusive"));12021203/*1204 * From here on, new_branch will contain the branch to be checked out,1205 * and new_branch_force and new_orphan_branch will tell us which one of1206 * -b/-B/--orphan is being used.1207 */1208if(opts.new_branch_force)1209 opts.new_branch = opts.new_branch_force;12101211if(opts.new_orphan_branch)1212 opts.new_branch = opts.new_orphan_branch;12131214/* --track without -b/-B/--orphan should DWIM */1215if(opts.track != BRANCH_TRACK_UNSPECIFIED && !opts.new_branch) {1216const char*argv0 = argv[0];1217if(!argc || !strcmp(argv0,"--"))1218die(_("--track needs a branch name"));1219skip_prefix(argv0,"refs/", &argv0);1220skip_prefix(argv0,"remotes/", &argv0);1221 argv0 =strchr(argv0,'/');1222if(!argv0 || !argv0[1])1223die(_("Missing branch name; try -b"));1224 opts.new_branch = argv0 +1;1225}12261227/*1228 * Extract branch name from command line arguments, so1229 * all that is left is pathspecs.1230 *1231 * Handle1232 *1233 * 1) git checkout <tree> -- [<paths>]1234 * 2) git checkout -- [<paths>]1235 * 3) git checkout <something> [<paths>]1236 *1237 * including "last branch" syntax and DWIM-ery for names of1238 * remote branches, erroring out for invalid or ambiguous cases.1239 */1240if(argc) {1241struct object_id rev;1242int dwim_ok =1243!opts.patch_mode &&1244 dwim_new_local_branch &&1245 opts.track == BRANCH_TRACK_UNSPECIFIED &&1246!opts.new_branch;1247int n =parse_branchname_arg(argc, argv, dwim_ok,1248&new, &opts, &rev);1249 argv += n;1250 argc -= n;1251}12521253if(argc) {1254parse_pathspec(&opts.pathspec,0,1255 opts.patch_mode ? PATHSPEC_PREFIX_ORIGIN :0,1256 prefix, argv);12571258if(!opts.pathspec.nr)1259die(_("invalid path specification"));12601261/*1262 * Try to give more helpful suggestion.1263 * new_branch && argc > 1 will be caught later.1264 */1265if(opts.new_branch && argc ==1)1266die(_("'%s' is not a commit and a branch '%s' cannot be created from it"),1267 argv[0], opts.new_branch);12681269if(opts.force_detach)1270die(_("git checkout: --detach does not take a path argument '%s'"),1271 argv[0]);12721273if(1< !!opts.writeout_stage + !!opts.force + !!opts.merge)1274die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\n"1275"checking out of the index."));1276}12771278if(opts.new_branch) {1279struct strbuf buf = STRBUF_INIT;12801281 opts.branch_exists =1282validate_new_branchname(opts.new_branch, &buf,1283!!opts.new_branch_force,1284!!opts.new_branch_force);12851286strbuf_release(&buf);1287}12881289UNLEAK(opts);1290if(opts.patch_mode || opts.pathspec.nr)1291returncheckout_paths(&opts,new.name);1292else1293returncheckout_branch(&opts, &new);1294}