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         /* not set by parse_options */
  36         int branch_exists;
  37
  38         const char *new_branch;
  39         const char *new_branch_force;
  40         const char *new_orphan_branch;
  41         int new_branch_log;
  42         enum branch_track track;
  43 };
  44
  45 static int post_checkout_hook(struct commit *old, struct commit *new,
  46                               int changed)
  47 {
  48         return run_hook(NULL, "post-checkout",
  49                         sha1_to_hex(old ? old->object.sha1 : null_sha1),
  50                         sha1_to_hex(new ? new->object.sha1 : null_sha1),
  51                         changed ? "1" : "0", NULL);
  52         /* "new" can be NULL when checking out from the index before
  53            a commit exists. */
  54
  55 }
  56
  57 static int update_some(const unsigned char *sha1, const char *base, int baselen,
  58                 const char *pathname, unsigned mode, int stage, void *context)
  59 {
  60         int len;
  61         struct cache_entry *ce;
  62
  63         if (S_ISDIR(mode))
  64                 return READ_TREE_RECURSIVE;
  65
  66         len = baselen + strlen(pathname);
  67         ce = xcalloc(1, cache_entry_size(len));
  68         hashcpy(ce->sha1, sha1);
  69         memcpy(ce->name, base, baselen);
  70         memcpy(ce->name + baselen, pathname, len - baselen);
  71         ce->ce_flags = create_ce_flags(len, 0);
  72         ce->ce_mode = create_ce_mode(mode);
  73         add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
  74         return 0;
  75 }
  76
  77 static int read_tree_some(struct tree *tree, const char **pathspec)
  78 {
  79         read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
  80
  81         /* update the index with the given tree's info
  82          * for all args, expanding wildcards, and exit
  83          * with any non-zero return code.
  84          */
  85         return 0;
  86 }
  87
  88 static int skip_same_name(struct cache_entry *ce, int pos)
  89 {
  90         while (++pos < active_nr &&
  91                !strcmp(active_cache[pos]->name, ce->name))
  92                 ; /* skip */
  93         return pos;
  94 }
  95
  96 static int check_stage(int stage, struct cache_entry *ce, int pos)
  97 {
  98         while (pos < active_nr &&
  99                !strcmp(active_cache[pos]->name, ce->name)) {
 100                 if (ce_stage(active_cache[pos]) == stage)
 101                         return 0;
 102                 pos++;
 103         }
 104         return error("path '%s' does not have %s version",
 105                      ce->name,
 106                      (stage == 2) ? "our" : "their");
 107 }
 108
 109 static int check_all_stages(struct cache_entry *ce, int pos)
 110 {
 111         if (ce_stage(ce) != 1 ||
 112             active_nr <= pos + 2 ||
 113             strcmp(active_cache[pos+1]->name, ce->name) ||
 114             ce_stage(active_cache[pos+1]) != 2 ||
 115             strcmp(active_cache[pos+2]->name, ce->name) ||
 116             ce_stage(active_cache[pos+2]) != 3)
 117                 return error("path '%s' does not have all three versions",
 118                              ce->name);
 119         return 0;
 120 }
 121
 122 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 123                           struct checkout *state)
 124 {
 125         while (pos < active_nr &&
 126                !strcmp(active_cache[pos]->name, ce->name)) {
 127                 if (ce_stage(active_cache[pos]) == stage)
 128                         return checkout_entry(active_cache[pos], state, NULL);
 129                 pos++;
 130         }
 131         return error("path '%s' does not have %s version",
 132                      ce->name,
 133                      (stage == 2) ? "our" : "their");
 134 }
 135
 136 static int checkout_merged(int pos, struct checkout *state)
 137 {
 138         struct cache_entry *ce = active_cache[pos];
 139         const char *path = ce->name;
 140         mmfile_t ancestor, ours, theirs;
 141         int status;
 142         unsigned char sha1[20];
 143         mmbuffer_t result_buf;
 144
 145         if (ce_stage(ce) != 1 ||
 146             active_nr <= pos + 2 ||
 147             strcmp(active_cache[pos+1]->name, path) ||
 148             ce_stage(active_cache[pos+1]) != 2 ||
 149             strcmp(active_cache[pos+2]->name, path) ||
 150             ce_stage(active_cache[pos+2]) != 3)
 151                 return error("path '%s' does not have all 3 versions", path);
 152
 153         read_mmblob(&ancestor, active_cache[pos]->sha1);
 154         read_mmblob(&ours, active_cache[pos+1]->sha1);
 155         read_mmblob(&theirs, active_cache[pos+2]->sha1);
 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,
 519                                       opts->new_branch_force ? 1 : 0,
 520                                       opts->new_branch_log, opts->track);
 521                 new->name = opts->new_branch;
 522                 setup_branch_path(new);
 523         }
 524
 525         old_desc = old->name;
 526         if (!old_desc && old->commit)
 527                 old_desc = sha1_to_hex(old->commit->object.sha1);
 528         strbuf_addf(&msg, "checkout: moving from %s to %s",
 529                     old_desc ? old_desc : "(invalid)", new->name);
 530
 531         if (new->path) {
 532                 create_symref("HEAD", new->path, msg.buf);
 533                 if (!opts->quiet) {
 534                         if (old->path && !strcmp(new->path, old->path))
 535                                 fprintf(stderr, "Already on '%s'\n",
 536                                         new->name);
 537                         else
 538                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 539                                         opts->branch_exists ? " and reset" : " a new",
 540                                         new->name);
 541                 }
 542                 if (old->path && old->name) {
 543                         char log_file[PATH_MAX], ref_file[PATH_MAX];
 544
 545                         git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 546                         git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 547                         if (!file_exists(ref_file) && file_exists(log_file))
 548                                 remove_path(log_file);
 549                 }
 550         } else if (strcmp(new->name, "HEAD")) {
 551                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 552                            REF_NODEREF, DIE_ON_ERR);
 553                 if (!opts->quiet) {
 554                         if (old->path && advice_detached_head)
 555                                 detach_advice(old->path, new->name);
 556                         describe_detached_head("HEAD is now at", new->commit);
 557                 }
 558         }
 559         remove_branch_state();
 560         strbuf_release(&msg);
 561         if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 562                 report_tracking(new);
 563 }
 564
 565 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 566 {
 567         int ret = 0;
 568         struct branch_info old;
 569         unsigned char rev[20];
 570         int flag;
 571         memset(&old, 0, sizeof(old));
 572         old.path = resolve_ref("HEAD", rev, 0, &flag);
 573         old.commit = lookup_commit_reference_gently(rev, 1);
 574         if (!(flag & REF_ISSYMREF))
 575                 old.path = NULL;
 576
 577         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 578                 old.name = old.path + strlen("refs/heads/");
 579
 580         if (!new->name) {
 581                 new->name = "HEAD";
 582                 new->commit = old.commit;
 583                 if (!new->commit)
 584                         die("You are on a branch yet to be born");
 585                 parse_commit(new->commit);
 586         }
 587
 588         ret = merge_working_tree(opts, &old, new);
 589         if (ret)
 590                 return ret;
 591
 592         /*
 593          * If we were on a detached HEAD, but have now moved to
 594          * a new commit, we want to mention the old commit once more
 595          * to remind the user that it might be lost.
 596          */
 597         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 598                 describe_detached_head("Previous HEAD position was", old.commit);
 599
 600         update_refs_for_switch(opts, &old, new);
 601
 602         ret = post_checkout_hook(old.commit, new->commit, 1);
 603         return ret || opts->writeout_error;
 604 }
 605
 606 static int git_checkout_config(const char *var, const char *value, void *cb)
 607 {
 608         return git_xmerge_config(var, value, cb);
 609 }
 610
 611 static int interactive_checkout(const char *revision, const char **pathspec,
 612                                 struct checkout_opts *opts)
 613 {
 614         return run_add_interactive(revision, "--patch=checkout", pathspec);
 615 }
 616
 617 struct tracking_name_data {
 618         const char *name;
 619         char *remote;
 620         int unique;
 621 };
 622
 623 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 624                                int flags, void *cb_data)
 625 {
 626         struct tracking_name_data *cb = cb_data;
 627         const char *slash;
 628
 629         if (prefixcmp(refname, "refs/remotes/"))
 630                 return 0;
 631         slash = strchr(refname + 13, '/');
 632         if (!slash || strcmp(slash + 1, cb->name))
 633                 return 0;
 634         if (cb->remote) {
 635                 cb->unique = 0;
 636                 return 0;
 637         }
 638         cb->remote = xstrdup(refname);
 639         return 0;
 640 }
 641
 642 static const char *unique_tracking_name(const char *name)
 643 {
 644         struct tracking_name_data cb_data = { NULL, NULL, 1 };
 645         cb_data.name = name;
 646         for_each_ref(check_tracking_name, &cb_data);
 647         if (cb_data.unique)
 648                 return cb_data.remote;
 649         free(cb_data.remote);
 650         return NULL;
 651 }
 652
 653 int cmd_checkout(int argc, const char **argv, const char *prefix)
 654 {
 655         struct checkout_opts opts;
 656         unsigned char rev[20];
 657         const char *arg;
 658         struct branch_info new;
 659         struct tree *source_tree = NULL;
 660         char *conflict_style = NULL;
 661         int patch_mode = 0;
 662         int dwim_new_local_branch = 1;
 663         struct option options[] = {
 664                 OPT__QUIET(&opts.quiet),
 665                 OPT_STRING('b', NULL, &opts.new_branch, "branch",
 666                            "create and checkout a new branch"),
 667                 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 668                            "create/reset and checkout a branch"),
 669                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 670                 OPT_SET_INT('t', "track",  &opts.track, "track",
 671                         BRANCH_TRACK_EXPLICIT),
 672                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 673                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 674                             2),
 675                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 676                             3),
 677                 OPT_BOOLEAN('f', "force", &opts.force, "force"),
 678                 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 679                 OPT_STRING(0, "conflict", &conflict_style, "style",
 680                            "conflict style (merge or diff3)"),
 681                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 682                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 683                   "second guess 'git checkout no-such-branch'",
 684                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 685                 OPT_END(),
 686         };
 687         int has_dash_dash;
 688
 689         memset(&opts, 0, sizeof(opts));
 690         memset(&new, 0, sizeof(new));
 691
 692         git_config(git_checkout_config, NULL);
 693
 694         opts.track = BRANCH_TRACK_UNSPECIFIED;
 695
 696         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 697                              PARSE_OPT_KEEP_DASHDASH);
 698
 699         /* we can assume from now on new_branch = !new_branch_force */
 700         if (opts.new_branch && opts.new_branch_force)
 701                 die("-B cannot be used with -b");
 702
 703         /* copy -B over to -b, so that we can just check the latter */
 704         if (opts.new_branch_force)
 705                 opts.new_branch = opts.new_branch_force;
 706
 707         if (patch_mode && (opts.track > 0 || opts.new_branch
 708                            || opts.new_branch_log || opts.merge || opts.force))
 709                 die ("--patch is incompatible with all other options");
 710
 711         /* --track without -b should DWIM */
 712         if (0 < opts.track && !opts.new_branch) {
 713                 const char *argv0 = argv[0];
 714                 if (!argc || !strcmp(argv0, "--"))
 715                         die ("--track needs a branch name");
 716                 if (!prefixcmp(argv0, "refs/"))
 717                         argv0 += 5;
 718                 if (!prefixcmp(argv0, "remotes/"))
 719                         argv0 += 8;
 720                 argv0 = strchr(argv0, '/');
 721                 if (!argv0 || !argv0[1])
 722                         die ("Missing branch name; try -b");
 723                 opts.new_branch = argv0 + 1;
 724         }
 725
 726         if (opts.new_orphan_branch) {
 727                 if (opts.new_branch)
 728                         die("--orphan and -b|-B are mutually exclusive");
 729                 if (opts.track > 0)
 730                         die("--orphan cannot be used with -t");
 731                 opts.new_branch = opts.new_orphan_branch;
 732         }
 733
 734         if (conflict_style) {
 735                 opts.merge = 1; /* implied */
 736                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 737         }
 738
 739         if (opts.force && opts.merge)
 740                 die("git checkout: -f and -m are incompatible");
 741
 742         /*
 743          * case 1: git checkout <ref> -- [<paths>]
 744          *
 745          *   <ref> must be a valid tree, everything after the '--' must be
 746          *   a path.
 747          *
 748          * case 2: git checkout -- [<paths>]
 749          *
 750          *   everything after the '--' must be paths.
 751          *
 752          * case 3: git checkout <something> [<paths>]
 753          *
 754          *   With no paths, if <something> is a commit, that is to
 755          *   switch to the branch or detach HEAD at it.  As a special case,
 756          *   if <something> is A...B (missing A or B means HEAD but you can
 757          *   omit at most one side), and if there is a unique merge base
 758          *   between A and B, A...B names that merge base.
 759          *
 760          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 761          *   was given, and there is a tracking branch whose name is
 762          *   <something> in one and only one remote, then this is a short-hand
 763          *   to fork local <something> from that remote tracking branch.
 764          *
 765          *   Otherwise <something> shall not be ambiguous.
 766          *   - If it's *only* a reference, treat it like case (1).
 767          *   - If it's only a path, treat it like case (2).
 768          *   - else: fail.
 769          *
 770          */
 771         if (argc) {
 772                 if (!strcmp(argv[0], "--")) {       /* case (2) */
 773                         argv++;
 774                         argc--;
 775                         goto no_reference;
 776                 }
 777
 778                 arg = argv[0];
 779                 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 780
 781                 if (!strcmp(arg, "-"))
 782                         arg = "@{-1}";
 783
 784                 if (get_sha1_mb(arg, rev)) {
 785                         if (has_dash_dash)          /* case (1) */
 786                                 die("invalid reference: %s", arg);
 787                         if (!patch_mode &&
 788                             dwim_new_local_branch &&
 789                             opts.track == BRANCH_TRACK_UNSPECIFIED &&
 790                             !opts.new_branch &&
 791                             !check_filename(NULL, arg) &&
 792                             argc == 1) {
 793                                 const char *remote = unique_tracking_name(arg);
 794                                 if (!remote || get_sha1(remote, rev))
 795                                         goto no_reference;
 796                                 opts.new_branch = arg;
 797                                 arg = remote;
 798                                 /* DWIMmed to create local branch */
 799                         }
 800                         else
 801                                 goto no_reference;
 802                 }
 803
 804                 /* we can't end up being in (2) anymore, eat the argument */
 805                 argv++;
 806                 argc--;
 807
 808                 new.name = arg;
 809                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 810                         setup_branch_path(&new);
 811
 812                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 813                             resolve_ref(new.path, rev, 1, NULL))
 814                                 ;
 815                         else
 816                                 new.path = NULL;
 817                         parse_commit(new.commit);
 818                         source_tree = new.commit->tree;
 819                 } else
 820                         source_tree = parse_tree_indirect(rev);
 821
 822                 if (!source_tree)                   /* case (1): want a tree */
 823                         die("reference is not a tree: %s", arg);
 824                 if (!has_dash_dash) {/* case (3 -> 1) */
 825                         /*
 826                          * Do not complain the most common case
 827                          *      git checkout branch
 828                          * even if there happen to be a file called 'branch';
 829                          * it would be extremely annoying.
 830                          */
 831                         if (argc)
 832                                 verify_non_filename(NULL, arg);
 833                 }
 834                 else {
 835                         argv++;
 836                         argc--;
 837                 }
 838         }
 839
 840 no_reference:
 841
 842         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 843                 opts.track = git_branch_track;
 844
 845         if (argc) {
 846                 const char **pathspec = get_pathspec(prefix, argv);
 847
 848                 if (!pathspec)
 849                         die("invalid path specification");
 850
 851                 if (patch_mode)
 852                         return interactive_checkout(new.name, pathspec, &opts);
 853
 854                 /* Checkout paths */
 855                 if (opts.new_branch) {
 856                         if (argc == 1) {
 857                                 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]);
 858                         } else {
 859                                 die("git checkout: updating paths is incompatible with switching branches.");
 860                         }
 861                 }
 862
 863                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 864                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 865
 866                 return checkout_paths(source_tree, pathspec, &opts);
 867         }
 868
 869         if (patch_mode)
 870                 return interactive_checkout(new.name, NULL, &opts);
 871
 872         if (opts.new_branch) {
 873                 struct strbuf buf = STRBUF_INIT;
 874                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 875                         die("git checkout: we do not like '%s' as a branch name.",
 876                             opts.new_branch);
 877                 if (!get_sha1(buf.buf, rev)) {
 878                         opts.branch_exists = 1;
 879                         if (!opts.new_branch_force)
 880                                 die("git checkout: branch %s already exists",
 881                                     opts.new_branch);
 882                 }
 883                 strbuf_release(&buf);
 884         }
 885
 886         if (new.name && !new.commit) {
 887                 die("Cannot switch branch to a non-commit.");
 888         }
 889         if (opts.writeout_stage)
 890                 die("--ours/--theirs is incompatible with switching branches.");
 891
 892         return switch_branches(&opts, &new);
 893 }