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", 0);
 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(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                                            (unsigned char *)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 (new->path) {
 546                 create_symref("HEAD", new->path, msg.buf);
 547                 if (!opts->quiet) {
 548                         if (old->path && !strcmp(new->path, old->path))
 549                                 fprintf(stderr, "Already on '%s'\n",
 550                                         new->name);
 551                         else if (opts->new_branch)
 552                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 553                                         opts->branch_exists ? " and reset" : " a new",
 554                                         new->name);
 555                         else
 556                                 fprintf(stderr, "Switched to branch '%s'\n",
 557                                         new->name);
 558                 }
 559                 if (old->path && old->name) {
 560                         char log_file[PATH_MAX], ref_file[PATH_MAX];
 561
 562                         git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 563                         git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 564                         if (!file_exists(ref_file) && file_exists(log_file))
 565                                 remove_path(log_file);
 566                 }
 567         } else if (opts->force_detach || strcmp(new->name, "HEAD")) {
 568                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 569                            REF_NODEREF, DIE_ON_ERR);
 570                 if (!opts->quiet) {
 571                         if (old->path && advice_detached_head)
 572                                 detach_advice(old->path, new->name);
 573                         describe_detached_head("HEAD is now at", new->commit);
 574                 }
 575         }
 576         remove_branch_state();
 577         strbuf_release(&msg);
 578         if (!opts->quiet &&
 579             (new->path || (!opts->force_detach && !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 static int parse_branchname_arg(int argc, const char **argv,
 681                                 int dwim_new_local_branch_ok,
 682                                 int force_detach,
 683                                 struct branch_info *new,
 684                                 struct tree **source_tree,
 685                                 unsigned char rev[20],
 686                                 const char **new_branch)
 687 {
 688         int argcount = 0;
 689         unsigned char branch_rev[20];
 690         const char *arg;
 691         int has_dash_dash;
 692
 693         /*
 694          * case 1: git checkout <ref> -- [<paths>]
 695          *
 696          *   <ref> must be a valid tree, everything after the '--' must be
 697          *   a path.
 698          *
 699          * case 2: git checkout -- [<paths>]
 700          *
 701          *   everything after the '--' must be paths.
 702          *
 703          * case 3: git checkout <something> [<paths>]
 704          *
 705          *   With no paths, if <something> is a commit, that is to
 706          *   switch to the branch or detach HEAD at it.  As a special case,
 707          *   if <something> is A...B (missing A or B means HEAD but you can
 708          *   omit at most one side), and if there is a unique merge base
 709          *   between A and B, A...B names that merge base.
 710          *
 711          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 712          *   was given, and there is a tracking branch whose name is
 713          *   <something> in one and only one remote, then this is a short-hand
 714          *   to fork local <something> from that remote tracking branch.
 715          *
 716          *   Otherwise <something> shall not be ambiguous.
 717          *   - If it's *only* a reference, treat it like case (1).
 718          *   - If it's only a path, treat it like case (2).
 719          *   - else: fail.
 720          *
 721          */
 722         if (!argc)
 723                 return 0;
 724
 725         if (!strcmp(argv[0], "--"))     /* case (2) */
 726                 return 1;
 727
 728         arg = argv[0];
 729         has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 730
 731         if (!strcmp(arg, "-"))
 732                 arg = "@{-1}";
 733
 734         if (get_sha1_mb(arg, rev)) {
 735                 if (has_dash_dash)          /* case (1) */
 736                         die("invalid reference: %s", arg);
 737                 if (dwim_new_local_branch_ok &&
 738                     !check_filename(NULL, arg) &&
 739                     argc == 1) {
 740                         const char *remote = unique_tracking_name(arg);
 741                         if (!remote || get_sha1(remote, rev))
 742                                 return argcount;
 743                         *new_branch = arg;
 744                         arg = remote;
 745                         /* DWIMmed to create local branch */
 746                 } else {
 747                         return argcount;
 748                 }
 749         }
 750
 751         /* we can't end up being in (2) anymore, eat the argument */
 752         argcount++;
 753         argv++;
 754         argc--;
 755
 756         new->name = arg;
 757         setup_branch_path(new);
 758
 759         if (!force_detach &&
 760             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),
 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_BOOLEAN('f', "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,
 910                                 dwim_ok, opts.force_detach,
 911                                 &new, &source_tree, rev, &opts.new_branch);
 912                 argv += n;
 913                 argc -= n;
 914         }
 915
 916         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 917                 opts.track = git_branch_track;
 918
 919         if (argc) {
 920                 const char **pathspec = get_pathspec(prefix, argv);
 921
 922                 if (!pathspec)
 923                         die("invalid path specification");
 924
 925                 if (patch_mode)
 926                         return interactive_checkout(new.name, pathspec, &opts);
 927
 928                 /* Checkout paths */
 929                 if (opts.new_branch) {
 930                         if (argc == 1) {
 931                                 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]);
 932                         } else {
 933                                 die("git checkout: updating paths is incompatible with switching branches.");
 934                         }
 935                 }
 936
 937                 if (opts.force_detach)
 938                         die("git checkout: --detach does not take a path argument");
 939
 940                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 941                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 942
 943                 return checkout_paths(source_tree, pathspec, &opts);
 944         }
 945
 946         if (patch_mode)
 947                 return interactive_checkout(new.name, NULL, &opts);
 948
 949         if (opts.new_branch) {
 950                 struct strbuf buf = STRBUF_INIT;
 951                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 952                         die("git checkout: we do not like '%s' as a branch name.",
 953                             opts.new_branch);
 954                 if (!get_sha1(buf.buf, rev)) {
 955                         opts.branch_exists = 1;
 956                         if (!opts.new_branch_force)
 957                                 die("git checkout: branch %s already exists",
 958                                     opts.new_branch);
 959                 }
 960                 strbuf_release(&buf);
 961         }
 962
 963         if (new.name && !new.commit) {
 964                 die("Cannot switch branch to a non-commit.");
 965         }
 966         if (opts.writeout_stage)
 967                 die("--ours/--theirs is incompatible with switching branches.");
 968
 969         return switch_branches(&opts, &new);
 970 }