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