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