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

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