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