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