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