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