git.oblomov.eu Git - git/blob - builtin/checkout.c

   1 #include "cache.h"
   2 #include "builtin.h"
   3 #include "parse-options.h"
   4 #include "refs.h"
   5 #include "commit.h"
   6 #include "tree.h"
   7 #include "tree-walk.h"
   8 #include "cache-tree.h"
   9 #include "unpack-trees.h"
  10 #include "dir.h"
  11 #include "run-command.h"
  12 #include "merge-recursive.h"
  13 #include "branch.h"
  14 #include "diff.h"
  15 #include "revision.h"
  16 #include "remote.h"
  17 #include "blob.h"
  18 #include "xdiff-interface.h"
  19 #include "ll-merge.h"
  20 #include "resolve-undo.h"
  21 #include "submodule.h"
  22
  23 static const char * const checkout_usage[] = {
  24         "git checkout [options] <branch>",
  25         "git checkout [options] [<branch>] -- <file>...",
  26         NULL,
  27 };
  28
  29 struct checkout_opts {
  30         int quiet;
  31         int merge;
  32         int force;
  33         int force_detach;
  34         int writeout_stage;
  35         int writeout_error;
  36
  37         /* not set by parse_options */
  38         int branch_exists;
  39
  40         const char *new_branch;
  41         const char *new_branch_force;
  42         const char *new_orphan_branch;
  43         int new_branch_log;
  44         enum branch_track track;
  45         struct diff_options diff_options;
  46 };
  47
  48 static int post_checkout_hook(struct commit *old, struct commit *new,
  49                               int changed)
  50 {
  51         return run_hook(NULL, "post-checkout",
  52                         sha1_to_hex(old ? old->object.sha1 : null_sha1),
  53                         sha1_to_hex(new ? new->object.sha1 : null_sha1),
  54                         changed ? "1" : "0", NULL);
  55         /* "new" can be NULL when checking out from the index before
  56            a commit exists. */
  57
  58 }
  59
  60 static int update_some(const unsigned char *sha1, const char *base, int baselen,
  61                 const char *pathname, unsigned mode, int stage, void *context)
  62 {
  63         int len;
  64         struct cache_entry *ce;
  65
  66         if (S_ISDIR(mode))
  67                 return READ_TREE_RECURSIVE;
  68
  69         len = baselen + strlen(pathname);
  70         ce = xcalloc(1, cache_entry_size(len));
  71         hashcpy(ce->sha1, sha1);
  72         memcpy(ce->name, base, baselen);
  73         memcpy(ce->name + baselen, pathname, len - baselen);
  74         ce->ce_flags = create_ce_flags(len, 0);
  75         ce->ce_mode = create_ce_mode(mode);
  76         add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
  77         return 0;
  78 }
  79
  80 static int read_tree_some(struct tree *tree, const char **pathspec)
  81 {
  82         read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
  83
  84         /* update the index with the given tree's info
  85          * for all args, expanding wildcards, and exit
  86          * with any non-zero return code.
  87          */
  88         return 0;
  89 }
  90
  91 static int skip_same_name(struct cache_entry *ce, int pos)
  92 {
  93         while (++pos < active_nr &&
  94                !strcmp(active_cache[pos]->name, ce->name))
  95                 ; /* skip */
  96         return pos;
  97 }
  98
  99 static int check_stage(int stage, struct cache_entry *ce, int pos)
 100 {
 101         while (pos < active_nr &&
 102                !strcmp(active_cache[pos]->name, ce->name)) {
 103                 if (ce_stage(active_cache[pos]) == stage)
 104                         return 0;
 105                 pos++;
 106         }
 107         if (stage == 2)
 108                 return error(_("path '%s' does not have our version"), ce->name);
 109         else
 110                 return error(_("path '%s' does not have their version"), ce->name);
 111 }
 112
 113 static int check_stages(unsigned stages, struct cache_entry *ce, int pos)
 114 {
 115         unsigned seen = 0;
 116         const char *name = ce->name;
 117
 118         while (pos < active_nr) {
 119                 ce = active_cache[pos];
 120                 if (strcmp(name, ce->name))
 121                         break;
 122                 seen |= (1 << ce_stage(ce));
 123                 pos++;
 124         }
 125         if ((stages & seen) != stages)
 126                 return error(_("path '%s' does not have all necessary versions"),
 127                              name);
 128         return 0;
 129 }
 130
 131 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 132                           struct checkout *state)
 133 {
 134         while (pos < active_nr &&
 135                !strcmp(active_cache[pos]->name, ce->name)) {
 136                 if (ce_stage(active_cache[pos]) == stage)
 137                         return checkout_entry(active_cache[pos], state, NULL);
 138                 pos++;
 139         }
 140         if (stage == 2)
 141                 return error(_("path '%s' does not have our version"), ce->name);
 142         else
 143                 return error(_("path '%s' does not have their version"), ce->name);
 144 }
 145
 146 static int checkout_merged(int pos, struct checkout *state)
 147 {
 148         struct cache_entry *ce = active_cache[pos];
 149         const char *path = ce->name;
 150         mmfile_t ancestor, ours, theirs;
 151         int status;
 152         unsigned char sha1[20];
 153         mmbuffer_t result_buf;
 154         unsigned char threeway[3][20];
 155         unsigned mode = 0;
 156
 157         memset(threeway, 0, sizeof(threeway));
 158         while (pos < active_nr) {
 159                 int stage;
 160                 stage = ce_stage(ce);
 161                 if (!stage || strcmp(path, ce->name))
 162                         break;
 163                 hashcpy(threeway[stage - 1], ce->sha1);
 164                 if (stage == 2)
 165                         mode = create_ce_mode(ce->ce_mode);
 166                 pos++;
 167                 ce = active_cache[pos];
 168         }
 169         if (is_null_sha1(threeway[1]) || is_null_sha1(threeway[2]))
 170                 return error(_("path '%s' does not have necessary versions"), path);
 171
 172         read_mmblob(&ancestor, threeway[0]);
 173         read_mmblob(&ours, threeway[1]);
 174         read_mmblob(&theirs, threeway[2]);
 175
 176         /*
 177          * NEEDSWORK: re-create conflicts from merges with
 178          * merge.renormalize set, too
 179          */
 180         status = ll_merge(&result_buf, path, &ancestor, "base",
 181                           &ours, "ours", &theirs, "theirs", NULL);
 182         free(ancestor.ptr);
 183         free(ours.ptr);
 184         free(theirs.ptr);
 185         if (status < 0 || !result_buf.ptr) {
 186                 free(result_buf.ptr);
 187                 return error(_("path '%s': cannot merge"), path);
 188         }
 189
 190         /*
 191          * NEEDSWORK:
 192          * There is absolutely no reason to write this as a blob object
 193          * and create a phony cache entry just to leak.  This hack is
 194          * primarily to get to the write_entry() machinery that massages
 195          * the contents to work-tree format and writes out which only
 196          * allows it for a cache entry.  The code in write_entry() needs
 197          * to be refactored to allow us to feed a <buffer, size, mode>
 198          * instead of a cache entry.  Such a refactoring would help
 199          * merge_recursive as well (it also writes the merge result to the
 200          * object database even when it may contain conflicts).
 201          */
 202         if (write_sha1_file(result_buf.ptr, result_buf.size,
 203                             blob_type, sha1))
 204                 die(_("Unable to add merge result for '%s'"), path);
 205         ce = make_cache_entry(mode, sha1, path, 2, 0);
 206         if (!ce)
 207                 die(_("make_cache_entry failed for path '%s'"), path);
 208         status = checkout_entry(ce, state, NULL);
 209         return status;
 210 }
 211
 212 static int checkout_paths(struct tree *source_tree, const char **pathspec,
 213                           struct checkout_opts *opts)
 214 {
 215         int pos;
 216         struct checkout state;
 217         static char *ps_matched;
 218         unsigned char rev[20];
 219         int flag;
 220         struct commit *head;
 221         int errs = 0;
 222         int stage = opts->writeout_stage;
 223         int merge = opts->merge;
 224         int newfd;
 225         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 226
 227         newfd = hold_locked_index(lock_file, 1);
 228         if (read_cache_preload(pathspec) < 0)
 229                 return error(_("corrupt index file"));
 230
 231         if (source_tree)
 232                 read_tree_some(source_tree, pathspec);
 233
 234         for (pos = 0; pathspec[pos]; pos++)
 235                 ;
 236         ps_matched = xcalloc(1, pos);
 237
 238         for (pos = 0; pos < active_nr; pos++) {
 239                 struct cache_entry *ce = active_cache[pos];
 240                 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
 241         }
 242
 243         if (report_path_error(ps_matched, pathspec, 0))
 244                 return 1;
 245
 246         /* "checkout -m path" to recreate conflicted state */
 247         if (opts->merge)
 248                 unmerge_cache(pathspec);
 249
 250         /* Any unmerged paths? */
 251         for (pos = 0; pos < active_nr; pos++) {
 252                 struct cache_entry *ce = active_cache[pos];
 253                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 254                         if (!ce_stage(ce))
 255                                 continue;
 256                         if (opts->force) {
 257                                 warning(_("path '%s' is unmerged"), ce->name);
 258                         } else if (stage) {
 259                                 errs |= check_stage(stage, ce, pos);
 260                         } else if (opts->merge) {
 261                                 errs |= check_stages((1<<2) | (1<<3), ce, pos);
 262                         } else {
 263                                 errs = 1;
 264                                 error(_("path '%s' is unmerged"), ce->name);
 265                         }
 266                         pos = skip_same_name(ce, pos) - 1;
 267                 }
 268         }
 269         if (errs)
 270                 return 1;
 271
 272         /* Now we are committed to check them out */
 273         memset(&state, 0, sizeof(state));
 274         state.force = 1;
 275         state.refresh_cache = 1;
 276         for (pos = 0; pos < active_nr; pos++) {
 277                 struct cache_entry *ce = active_cache[pos];
 278                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 279                         if (!ce_stage(ce)) {
 280                                 errs |= checkout_entry(ce, &state, NULL);
 281                                 continue;
 282                         }
 283                         if (stage)
 284                                 errs |= checkout_stage(stage, ce, pos, &state);
 285                         else if (merge)
 286                                 errs |= checkout_merged(pos, &state);
 287                         pos = skip_same_name(ce, pos) - 1;
 288                 }
 289         }
 290
 291         if (write_cache(newfd, active_cache, active_nr) ||
 292             commit_locked_index(lock_file))
 293                 die(_("unable to write new index file"));
 294
 295         resolve_ref("HEAD", rev, 0, &flag);
 296         head = lookup_commit_reference_gently(rev, 1);
 297
 298         errs |= post_checkout_hook(head, head, 0);
 299         return errs;
 300 }
 301
 302 static void show_local_changes(struct object *head, struct diff_options *opts)
 303 {
 304         struct rev_info rev;
 305         /* I think we want full paths, even if we're in a subdirectory. */
 306         init_revisions(&rev, NULL);
 307         rev.diffopt.flags = opts->flags;
 308         rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 309         if (diff_setup_done(&rev.diffopt) < 0)
 310                 die(_("diff_setup_done failed"));
 311         add_pending_object(&rev, head, NULL);
 312         run_diff_index(&rev, 0);
 313 }
 314
 315 static void describe_detached_head(const char *msg, struct commit *commit)
 316 {
 317         struct strbuf sb = STRBUF_INIT;
 318         struct pretty_print_context ctx = {0};
 319         parse_commit(commit);
 320         pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
 321         fprintf(stderr, "%s %s... %s\n", msg,
 322                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
 323         strbuf_release(&sb);
 324 }
 325
 326 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
 327 {
 328         struct unpack_trees_options opts;
 329         struct tree_desc tree_desc;
 330
 331         memset(&opts, 0, sizeof(opts));
 332         opts.head_idx = -1;
 333         opts.update = worktree;
 334         opts.skip_unmerged = !worktree;
 335         opts.reset = 1;
 336         opts.merge = 1;
 337         opts.fn = oneway_merge;
 338         opts.verbose_update = !o->quiet;
 339         opts.src_index = &the_index;
 340         opts.dst_index = &the_index;
 341         parse_tree(tree);
 342         init_tree_desc(&tree_desc, tree->buffer, tree->size);
 343         switch (unpack_trees(1, &tree_desc, &opts)) {
 344         case -2:
 345                 o->writeout_error = 1;
 346                 /*
 347                  * We return 0 nevertheless, as the index is all right
 348                  * and more importantly we have made best efforts to
 349                  * update paths in the work tree, and we cannot revert
 350                  * them.
 351                  */
 352         case 0:
 353                 return 0;
 354         default:
 355                 return 128;
 356         }
 357 }
 358
 359 struct branch_info {
 360         const char *name; /* The short name used */
 361         const char *path; /* The full name of a real branch */
 362         struct commit *commit; /* The named commit */
 363 };
 364
 365 static void setup_branch_path(struct branch_info *branch)
 366 {
 367         struct strbuf buf = STRBUF_INIT;
 368
 369         strbuf_branchname(&buf, branch->name);
 370         if (strcmp(buf.buf, branch->name))
 371                 branch->name = xstrdup(buf.buf);
 372         strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 373         branch->path = strbuf_detach(&buf, NULL);
 374 }
 375
 376 static int merge_working_tree(struct checkout_opts *opts,
 377                               struct branch_info *old, struct branch_info *new)
 378 {
 379         int ret;
 380         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 381         int newfd = hold_locked_index(lock_file, 1);
 382
 383         if (read_cache_preload(NULL) < 0)
 384                 return error(_("corrupt index file"));
 385
 386         resolve_undo_clear();
 387         if (opts->force) {
 388                 ret = reset_tree(new->commit->tree, opts, 1);
 389                 if (ret)
 390                         return ret;
 391         } else {
 392                 struct tree_desc trees[2];
 393                 struct tree *tree;
 394                 struct unpack_trees_options topts;
 395
 396                 memset(&topts, 0, sizeof(topts));
 397                 topts.head_idx = -1;
 398                 topts.src_index = &the_index;
 399                 topts.dst_index = &the_index;
 400
 401                 setup_unpack_trees_porcelain(&topts, "checkout");
 402
 403                 refresh_cache(REFRESH_QUIET);
 404
 405                 if (unmerged_cache()) {
 406                         error(_("you need to resolve your current index first"));
 407                         return 1;
 408                 }
 409
 410                 /* 2-way merge to the new branch */
 411                 topts.initial_checkout = is_cache_unborn();
 412                 topts.update = 1;
 413                 topts.merge = 1;
 414                 topts.gently = opts->merge && old->commit;
 415                 topts.verbose_update = !opts->quiet;
 416                 topts.fn = twoway_merge;
 417                 topts.dir = xcalloc(1, sizeof(*topts.dir));
 418                 topts.dir->flags |= DIR_SHOW_IGNORED;
 419                 topts.dir->exclude_per_dir = ".gitignore";
 420                 tree = parse_tree_indirect(old->commit ?
 421                                            old->commit->object.sha1 :
 422                                            EMPTY_TREE_SHA1_BIN);
 423                 init_tree_desc(&trees[0], tree->buffer, tree->size);
 424                 tree = parse_tree_indirect(new->commit->object.sha1);
 425                 init_tree_desc(&trees[1], tree->buffer, tree->size);
 426
 427                 ret = unpack_trees(2, trees, &topts);
 428                 if (ret == -1) {
 429                         /*
 430                          * Unpack couldn't do a trivial merge; either
 431                          * give up or do a real merge, depending on
 432                          * whether the merge flag was used.
 433                          */
 434                         struct tree *result;
 435                         struct tree *work;
 436                         struct merge_options o;
 437                         if (!opts->merge)
 438                                 return 1;
 439
 440                         /*
 441                          * Without old->commit, the below is the same as
 442                          * the two-tree unpack we already tried and failed.
 443                          */
 444                         if (!old->commit)
 445                                 return 1;
 446
 447                         /* Do more real merge */
 448
 449                         /*
 450                          * We update the index fully, then write the
 451                          * tree from the index, then merge the new
 452                          * branch with the current tree, with the old
 453                          * branch as the base. Then we reset the index
 454                          * (but not the working tree) to the new
 455                          * branch, leaving the working tree as the
 456                          * merged version, but skipping unmerged
 457                          * entries in the index.
 458                          */
 459
 460                         add_files_to_cache(NULL, NULL, 0);
 461                         /*
 462                          * NEEDSWORK: carrying over local changes
 463                          * when branches have different end-of-line
 464                          * normalization (or clean+smudge rules) is
 465                          * a pain; plumb in an option to set
 466                          * o.renormalize?
 467                          */
 468                         init_merge_options(&o);
 469                         o.verbosity = 0;
 470                         work = write_tree_from_memory(&o);
 471
 472                         ret = reset_tree(new->commit->tree, opts, 1);
 473                         if (ret)
 474                                 return ret;
 475                         o.ancestor = old->name;
 476                         o.branch1 = new->name;
 477                         o.branch2 = "local";
 478                         merge_trees(&o, new->commit->tree, work,
 479                                 old->commit->tree, &result);
 480                         ret = reset_tree(new->commit->tree, opts, 0);
 481                         if (ret)
 482                                 return ret;
 483                 }
 484         }
 485
 486         if (write_cache(newfd, active_cache, active_nr) ||
 487             commit_locked_index(lock_file))
 488                 die(_("unable to write new index file"));
 489
 490         if (!opts->force && !opts->quiet)
 491                 show_local_changes(&new->commit->object, &opts->diff_options);
 492
 493         return 0;
 494 }
 495
 496 static void report_tracking(struct branch_info *new)
 497 {
 498         struct strbuf sb = STRBUF_INIT;
 499         struct branch *branch = branch_get(new->name);
 500
 501         if (!format_tracking_info(branch, &sb))
 502                 return;
 503         fputs(sb.buf, stdout);
 504         strbuf_release(&sb);
 505 }
 506
 507 static void detach_advice(const char *old_path, const char *new_name)
 508 {
 509         const char fmt[] =
 510         "Note: checking out '%s'.\n\n"
 511         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 512         "changes and commit them, and you can discard any commits you make in this\n"
 513         "state without impacting any branches by performing another checkout.\n\n"
 514         "If you want to create a new branch to retain commits you create, you may\n"
 515         "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 516         "  git checkout -b new_branch_name\n\n";
 517
 518         fprintf(stderr, fmt, new_name);
 519 }
 520
 521 static void update_refs_for_switch(struct checkout_opts *opts,
 522                                    struct branch_info *old,
 523                                    struct branch_info *new)
 524 {
 525         struct strbuf msg = STRBUF_INIT;
 526         const char *old_desc;
 527         if (opts->new_branch) {
 528                 if (opts->new_orphan_branch) {
 529                         if (opts->new_branch_log && !log_all_ref_updates) {
 530                                 int temp;
 531                                 char log_file[PATH_MAX];
 532                                 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
 533
 534                                 temp = log_all_ref_updates;
 535                                 log_all_ref_updates = 1;
 536                                 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
 537                                         fprintf(stderr, _("Can not do reflog for '%s'\n"),
 538                                             opts->new_orphan_branch);
 539                                         log_all_ref_updates = temp;
 540                                         return;
 541                                 }
 542                                 log_all_ref_updates = temp;
 543                         }
 544                 }
 545                 else
 546                         create_branch(old->name, opts->new_branch, new->name,
 547                                       opts->new_branch_force ? 1 : 0,
 548                                       opts->new_branch_log, opts->track);
 549                 new->name = opts->new_branch;
 550                 setup_branch_path(new);
 551         }
 552
 553         old_desc = old->name;
 554         if (!old_desc && old->commit)
 555                 old_desc = sha1_to_hex(old->commit->object.sha1);
 556         strbuf_addf(&msg, "checkout: moving from %s to %s",
 557                     old_desc ? old_desc : "(invalid)", new->name);
 558
 559         if (!strcmp(new->name, "HEAD") && !new->path && !opts->force_detach) {
 560                 /* Nothing to do. */
 561         } else if (opts->force_detach || !new->path) {  /* No longer on any branch. */
 562                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 563                            REF_NODEREF, DIE_ON_ERR);
 564                 if (!opts->quiet) {
 565                         if (old->path && advice_detached_head)
 566                                 detach_advice(old->path, new->name);
 567                         describe_detached_head(_("HEAD is now at"), new->commit);
 568                 }
 569         } else if (new->path) { /* Switch branches. */
 570                 create_symref("HEAD", new->path, msg.buf);
 571                 if (!opts->quiet) {
 572                         if (old->path && !strcmp(new->path, old->path)) {
 573                                 fprintf(stderr, _("Already on '%s'\n"),
 574                                         new->name);
 575                         } else if (opts->new_branch) {
 576                                 if (opts->branch_exists)
 577                                         fprintf(stderr, _("Switched to and reset branch '%s'\n"), new->name);
 578                                 else
 579                                         fprintf(stderr, _("Switched to a new branch '%s'\n"), new->name);
 580                         } else {
 581                                 fprintf(stderr, _("Switched to branch '%s'\n"),
 582                                         new->name);
 583                         }
 584                 }
 585                 if (old->path && old->name) {
 586                         char log_file[PATH_MAX], ref_file[PATH_MAX];
 587
 588                         git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 589                         git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 590                         if (!file_exists(ref_file) && file_exists(log_file))
 591                                 remove_path(log_file);
 592                 }
 593         }
 594         remove_branch_state();
 595         strbuf_release(&msg);
 596         if (!opts->quiet &&
 597             (new->path || (!opts->force_detach && !strcmp(new->name, "HEAD"))))
 598                 report_tracking(new);
 599 }
 600
 601 struct rev_list_args {
 602         int argc;
 603         int alloc;
 604         const char **argv;
 605 };
 606
 607 static void add_one_rev_list_arg(struct rev_list_args *args, const char *s)
 608 {
 609         ALLOC_GROW(args->argv, args->argc + 1, args->alloc);
 610         args->argv[args->argc++] = s;
 611 }
 612
 613 static int add_one_ref_to_rev_list_arg(const char *refname,
 614                                        const unsigned char *sha1,
 615                                        int flags,
 616                                        void *cb_data)
 617 {
 618         add_one_rev_list_arg(cb_data, refname);
 619         return 0;
 620 }
 621
 622 static int clear_commit_marks_from_one_ref(const char *refname,
 623                                       const unsigned char *sha1,
 624                                       int flags,
 625                                       void *cb_data)
 626 {
 627         struct commit *commit = lookup_commit_reference_gently(sha1, 1);
 628         if (commit)
 629                 clear_commit_marks(commit, -1);
 630         return 0;
 631 }
 632
 633 static void describe_one_orphan(struct strbuf *sb, struct commit *commit)
 634 {
 635         struct pretty_print_context ctx = { 0 };
 636
 637         parse_commit(commit);
 638         strbuf_addstr(sb, "  ");
 639         strbuf_addstr(sb,
 640                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
 641         strbuf_addch(sb, ' ');
 642         pretty_print_commit(CMIT_FMT_ONELINE, commit, sb, &ctx);
 643         strbuf_addch(sb, '\n');
 644 }
 645
 646 #define ORPHAN_CUTOFF 4
 647 static void suggest_reattach(struct commit *commit, struct rev_info *revs)
 648 {
 649         struct commit *c, *last = NULL;
 650         struct strbuf sb = STRBUF_INIT;
 651         int lost = 0;
 652         while ((c = get_revision(revs)) != NULL) {
 653                 if (lost < ORPHAN_CUTOFF)
 654                         describe_one_orphan(&sb, c);
 655                 last = c;
 656                 lost++;
 657         }
 658         if (ORPHAN_CUTOFF < lost) {
 659                 int more = lost - ORPHAN_CUTOFF;
 660                 if (more == 1)
 661                         describe_one_orphan(&sb, last);
 662                 else
 663                         strbuf_addf(&sb, " ... and %d more.\n", more);
 664         }
 665
 666         fprintf(stderr,
 667                 "Warning: you are leaving %d commit%s behind, "
 668                 "not connected to\n"
 669                 "any of your branches:\n\n"
 670                 "%s\n"
 671                 "If you want to keep them by creating a new branch, "
 672                 "this may be a good time\nto do so with:\n\n"
 673                 " git branch new_branch_name %s\n\n",
 674                 lost, ((1 < lost) ? "s" : ""),
 675                 sb.buf,
 676                 sha1_to_hex(commit->object.sha1));
 677         strbuf_release(&sb);
 678 }
 679
 680 /*
 681  * We are about to leave commit that was at the tip of a detached
 682  * HEAD.  If it is not reachable from any ref, this is the last chance
 683  * for the user to do so without resorting to reflog.
 684  */
 685 static void orphaned_commit_warning(struct commit *commit)
 686 {
 687         struct rev_list_args args = { 0, 0, NULL };
 688         struct rev_info revs;
 689
 690         add_one_rev_list_arg(&args, "(internal)");
 691         add_one_rev_list_arg(&args, sha1_to_hex(commit->object.sha1));
 692         add_one_rev_list_arg(&args, "--not");
 693         for_each_ref(add_one_ref_to_rev_list_arg, &args);
 694         add_one_rev_list_arg(&args, "--");
 695         add_one_rev_list_arg(&args, NULL);
 696
 697         init_revisions(&revs, NULL);
 698         if (setup_revisions(args.argc - 1, args.argv, &revs, NULL) != 1)
 699                 die(_("internal error: only -- alone should have been left"));
 700         if (prepare_revision_walk(&revs))
 701                 die(_("internal error in revision walk"));
 702         if (!(commit->object.flags & UNINTERESTING))
 703                 suggest_reattach(commit, &revs);
 704         else
 705                 describe_detached_head(_("Previous HEAD position was"), commit);
 706
 707         clear_commit_marks(commit, -1);
 708         for_each_ref(clear_commit_marks_from_one_ref, NULL);
 709 }
 710
 711 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 712 {
 713         int ret = 0;
 714         struct branch_info old;
 715         unsigned char rev[20];
 716         int flag;
 717         memset(&old, 0, sizeof(old));
 718         old.path = resolve_ref("HEAD", rev, 0, &flag);
 719         old.commit = lookup_commit_reference_gently(rev, 1);
 720         if (!(flag & REF_ISSYMREF))
 721                 old.path = NULL;
 722
 723         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 724                 old.name = old.path + strlen("refs/heads/");
 725
 726         if (!new->name) {
 727                 new->name = "HEAD";
 728                 new->commit = old.commit;
 729                 if (!new->commit)
 730                         die(_("You are on a branch yet to be born"));
 731                 parse_commit(new->commit);
 732         }
 733
 734         ret = merge_working_tree(opts, &old, new);
 735         if (ret)
 736                 return ret;
 737
 738         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 739                 orphaned_commit_warning(old.commit);
 740
 741         update_refs_for_switch(opts, &old, new);
 742
 743         ret = post_checkout_hook(old.commit, new->commit, 1);
 744         return ret || opts->writeout_error;
 745 }
 746
 747 static int git_checkout_config(const char *var, const char *value, void *cb)
 748 {
 749         if (!strcmp(var, "diff.ignoresubmodules")) {
 750                 struct checkout_opts *opts = cb;
 751                 handle_ignore_submodules_arg(&opts->diff_options, value);
 752                 return 0;
 753         }
 754
 755         if (!prefixcmp(var, "submodule."))
 756                 return parse_submodule_config_option(var, value);
 757
 758         return git_xmerge_config(var, value, NULL);
 759 }
 760
 761 static int interactive_checkout(const char *revision, const char **pathspec,
 762                                 struct checkout_opts *opts)
 763 {
 764         return run_add_interactive(revision, "--patch=checkout", pathspec);
 765 }
 766
 767 struct tracking_name_data {
 768         const char *name;
 769         char *remote;
 770         int unique;
 771 };
 772
 773 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 774                                int flags, void *cb_data)
 775 {
 776         struct tracking_name_data *cb = cb_data;
 777         const char *slash;
 778
 779         if (prefixcmp(refname, "refs/remotes/"))
 780                 return 0;
 781         slash = strchr(refname + 13, '/');
 782         if (!slash || strcmp(slash + 1, cb->name))
 783                 return 0;
 784         if (cb->remote) {
 785                 cb->unique = 0;
 786                 return 0;
 787         }
 788         cb->remote = xstrdup(refname);
 789         return 0;
 790 }
 791
 792 static const char *unique_tracking_name(const char *name)
 793 {
 794         struct tracking_name_data cb_data = { NULL, NULL, 1 };
 795         cb_data.name = name;
 796         for_each_ref(check_tracking_name, &cb_data);
 797         if (cb_data.unique)
 798                 return cb_data.remote;
 799         free(cb_data.remote);
 800         return NULL;
 801 }
 802
 803 static int parse_branchname_arg(int argc, const char **argv,
 804                                 int dwim_new_local_branch_ok,
 805                                 struct branch_info *new,
 806                                 struct tree **source_tree,
 807                                 unsigned char rev[20],
 808                                 const char **new_branch)
 809 {
 810         int argcount = 0;
 811         unsigned char branch_rev[20];
 812         const char *arg;
 813         int has_dash_dash;
 814
 815         /*
 816          * case 1: git checkout <ref> -- [<paths>]
 817          *
 818          *   <ref> must be a valid tree, everything after the '--' must be
 819          *   a path.
 820          *
 821          * case 2: git checkout -- [<paths>]
 822          *
 823          *   everything after the '--' must be paths.
 824          *
 825          * case 3: git checkout <something> [<paths>]
 826          *
 827          *   With no paths, if <something> is a commit, that is to
 828          *   switch to the branch or detach HEAD at it.  As a special case,
 829          *   if <something> is A...B (missing A or B means HEAD but you can
 830          *   omit at most one side), and if there is a unique merge base
 831          *   between A and B, A...B names that merge base.
 832          *
 833          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 834          *   was given, and there is a tracking branch whose name is
 835          *   <something> in one and only one remote, then this is a short-hand
 836          *   to fork local <something> from that remote-tracking branch.
 837          *
 838          *   Otherwise <something> shall not be ambiguous.
 839          *   - If it's *only* a reference, treat it like case (1).
 840          *   - If it's only a path, treat it like case (2).
 841          *   - else: fail.
 842          *
 843          */
 844         if (!argc)
 845                 return 0;
 846
 847         if (!strcmp(argv[0], "--"))     /* case (2) */
 848                 return 1;
 849
 850         arg = argv[0];
 851         has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 852
 853         if (!strcmp(arg, "-"))
 854                 arg = "@{-1}";
 855
 856         if (get_sha1_mb(arg, rev)) {
 857                 if (has_dash_dash)          /* case (1) */
 858                         die(_("invalid reference: %s"), arg);
 859                 if (dwim_new_local_branch_ok &&
 860                     !check_filename(NULL, arg) &&
 861                     argc == 1) {
 862                         const char *remote = unique_tracking_name(arg);
 863                         if (!remote || get_sha1(remote, rev))
 864                                 return argcount;
 865                         *new_branch = arg;
 866                         arg = remote;
 867                         /* DWIMmed to create local branch */
 868                 } else {
 869                         return argcount;
 870                 }
 871         }
 872
 873         /* we can't end up being in (2) anymore, eat the argument */
 874         argcount++;
 875         argv++;
 876         argc--;
 877
 878         new->name = arg;
 879         setup_branch_path(new);
 880
 881         if (check_ref_format(new->path) == CHECK_REF_FORMAT_OK &&
 882             resolve_ref(new->path, branch_rev, 1, NULL))
 883                 hashcpy(rev, branch_rev);
 884         else
 885                 new->path = NULL; /* not an existing branch */
 886
 887         new->commit = lookup_commit_reference_gently(rev, 1);
 888         if (!new->commit) {
 889                 /* not a commit */
 890                 *source_tree = parse_tree_indirect(rev);
 891         } else {
 892                 parse_commit(new->commit);
 893                 *source_tree = new->commit->tree;
 894         }
 895
 896         if (!*source_tree)                   /* case (1): want a tree */
 897                 die(_("reference is not a tree: %s"), arg);
 898         if (!has_dash_dash) {/* case (3 -> 1) */
 899                 /*
 900                  * Do not complain the most common case
 901                  *      git checkout branch
 902                  * even if there happen to be a file called 'branch';
 903                  * it would be extremely annoying.
 904                  */
 905                 if (argc)
 906                         verify_non_filename(NULL, arg);
 907         } else {
 908                 argcount++;
 909                 argv++;
 910                 argc--;
 911         }
 912
 913         return argcount;
 914 }
 915
 916 int cmd_checkout(int argc, const char **argv, const char *prefix)
 917 {
 918         struct checkout_opts opts;
 919         unsigned char rev[20];
 920         struct branch_info new;
 921         struct tree *source_tree = NULL;
 922         char *conflict_style = NULL;
 923         int patch_mode = 0;
 924         int dwim_new_local_branch = 1;
 925         struct option options[] = {
 926                 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
 927                 OPT_STRING('b', NULL, &opts.new_branch, "branch",
 928                            "create and checkout a new branch"),
 929                 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 930                            "create/reset and checkout a branch"),
 931                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
 932                 OPT_BOOLEAN(0, "detach", &opts.force_detach, "detach the HEAD at named commit"),
 933                 OPT_SET_INT('t', "track",  &opts.track, "set upstream info for new branch",
 934                         BRANCH_TRACK_EXPLICIT),
 935                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 936                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
 937                             2),
 938                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
 939                             3),
 940                 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
 941                 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
 942                 OPT_STRING(0, "conflict", &conflict_style, "style",
 943                            "conflict style (merge or diff3)"),
 944                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 945                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 946                   "second guess 'git checkout no-such-branch'",
 947                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 948                 OPT_END(),
 949         };
 950
 951         memset(&opts, 0, sizeof(opts));
 952         memset(&new, 0, sizeof(new));
 953
 954         gitmodules_config();
 955         git_config(git_checkout_config, &opts);
 956
 957         opts.track = BRANCH_TRACK_UNSPECIFIED;
 958
 959         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 960                              PARSE_OPT_KEEP_DASHDASH);
 961
 962         /* we can assume from now on new_branch = !new_branch_force */
 963         if (opts.new_branch && opts.new_branch_force)
 964                 die(_("-B cannot be used with -b"));
 965
 966         /* copy -B over to -b, so that we can just check the latter */
 967         if (opts.new_branch_force)
 968                 opts.new_branch = opts.new_branch_force;
 969
 970         if (patch_mode && (opts.track > 0 || opts.new_branch
 971                            || opts.new_branch_log || opts.merge || opts.force
 972                            || opts.force_detach))
 973                 die (_("--patch is incompatible with all other options"));
 974
 975         if (opts.force_detach && (opts.new_branch || opts.new_orphan_branch))
 976                 die("--detach cannot be used with -b/-B/--orphan");
 977         if (opts.force_detach && 0 < opts.track)
 978                 die("--detach cannot be used with -t");
 979
 980         /* --track without -b should DWIM */
 981         if (0 < opts.track && !opts.new_branch) {
 982                 const char *argv0 = argv[0];
 983                 if (!argc || !strcmp(argv0, "--"))
 984                         die (_("--track needs a branch name"));
 985                 if (!prefixcmp(argv0, "refs/"))
 986                         argv0 += 5;
 987                 if (!prefixcmp(argv0, "remotes/"))
 988                         argv0 += 8;
 989                 argv0 = strchr(argv0, '/');
 990                 if (!argv0 || !argv0[1])
 991                         die (_("Missing branch name; try -b"));
 992                 opts.new_branch = argv0 + 1;
 993         }
 994
 995         if (opts.new_orphan_branch) {
 996                 if (opts.new_branch)
 997                         die(_("--orphan and -b|-B are mutually exclusive"));
 998                 if (opts.track > 0)
 999                         die(_("--orphan cannot be used with -t"));
1000                 opts.new_branch = opts.new_orphan_branch;
1001         }
1002
1003         if (conflict_style) {
1004                 opts.merge = 1; /* implied */
1005                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
1006         }
1007
1008         if (opts.force && opts.merge)
1009                 die(_("git checkout: -f and -m are incompatible"));
1010
1011         /*
1012          * Extract branch name from command line arguments, so
1013          * all that is left is pathspecs.
1014          *
1015          * Handle
1016          *
1017          *  1) git checkout <tree> -- [<paths>]
1018          *  2) git checkout -- [<paths>]
1019          *  3) git checkout <something> [<paths>]
1020          *
1021          * including "last branch" syntax and DWIM-ery for names of
1022          * remote branches, erroring out for invalid or ambiguous cases.
1023          */
1024         if (argc) {
1025                 int dwim_ok =
1026                         !patch_mode &&
1027                         dwim_new_local_branch &&
1028                         opts.track == BRANCH_TRACK_UNSPECIFIED &&
1029                         !opts.new_branch;
1030                 int n = parse_branchname_arg(argc, argv, dwim_ok,
1031                                 &new, &source_tree, rev, &opts.new_branch);
1032                 argv += n;
1033                 argc -= n;
1034         }
1035
1036         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
1037                 opts.track = git_branch_track;
1038
1039         if (argc) {
1040                 const char **pathspec = get_pathspec(prefix, argv);
1041
1042                 if (!pathspec)
1043                         die(_("invalid path specification"));
1044
1045                 if (patch_mode)
1046                         return interactive_checkout(new.name, pathspec, &opts);
1047
1048                 /* Checkout paths */
1049                 if (opts.new_branch) {
1050                         if (argc == 1) {
1051                                 die(_("git checkout: updating paths is incompatible with switching branches.\nDid you intend to checkout '%s' which can not be resolved as commit?"), argv[0]);
1052                         } else {
1053                                 die(_("git checkout: updating paths is incompatible with switching branches."));
1054                         }
1055                 }
1056
1057                 if (opts.force_detach)
1058                         die("git checkout: --detach does not take a path argument");
1059
1060                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
1061                         die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
1062
1063                 return checkout_paths(source_tree, pathspec, &opts);
1064         }
1065
1066         if (patch_mode)
1067                 return interactive_checkout(new.name, NULL, &opts);
1068
1069         if (opts.new_branch) {
1070                 struct strbuf buf = STRBUF_INIT;
1071                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
1072                         die(_("git checkout: we do not like '%s' as a branch name."),
1073                             opts.new_branch);
1074                 if (!get_sha1(buf.buf, rev)) {
1075                         opts.branch_exists = 1;
1076                         if (!opts.new_branch_force)
1077                                 die(_("git checkout: branch %s already exists"),
1078                                     opts.new_branch);
1079                 }
1080                 strbuf_release(&buf);
1081         }
1082
1083         if (new.name && !new.commit) {
1084                 die(_("Cannot switch branch to a non-commit."));
1085         }
1086         if (opts.writeout_stage)
1087                 die(_("--ours/--theirs is incompatible with switching branches."));
1088
1089         return switch_branches(&opts, &new);
1090 }