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