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.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 287         if (diff_setup_done(&rev.diffopt) < 0)
 288                 die("diff_setup_done failed");
 289         add_pending_object(&rev, head, NULL);
 290         run_diff_index(&rev, 0);
 291 }
 292
 293 static void describe_detached_head(char *msg, struct commit *commit)
 294 {
 295         struct strbuf sb = STRBUF_INIT;
 296         struct pretty_print_context ctx = {0};
 297         parse_commit(commit);
 298         pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
 299         fprintf(stderr, "%s %s... %s\n", msg,
 300                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
 301         strbuf_release(&sb);
 302 }
 303
 304 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
 305 {
 306         struct unpack_trees_options opts;
 307         struct tree_desc tree_desc;
 308
 309         memset(&opts, 0, sizeof(opts));
 310         opts.head_idx = -1;
 311         opts.update = worktree;
 312         opts.skip_unmerged = !worktree;
 313         opts.reset = 1;
 314         opts.merge = 1;
 315         opts.fn = oneway_merge;
 316         opts.verbose_update = !o->quiet;
 317         opts.src_index = &the_index;
 318         opts.dst_index = &the_index;
 319         parse_tree(tree);
 320         init_tree_desc(&tree_desc, tree->buffer, tree->size);
 321         switch (unpack_trees(1, &tree_desc, &opts)) {
 322         case -2:
 323                 o->writeout_error = 1;
 324                 /*
 325                  * We return 0 nevertheless, as the index is all right
 326                  * and more importantly we have made best efforts to
 327                  * update paths in the work tree, and we cannot revert
 328                  * them.
 329                  */
 330         case 0:
 331                 return 0;
 332         default:
 333                 return 128;
 334         }
 335 }
 336
 337 struct branch_info {
 338         const char *name; /* The short name used */
 339         const char *path; /* The full name of a real branch */
 340         struct commit *commit; /* The named commit */
 341 };
 342
 343 static void setup_branch_path(struct branch_info *branch)
 344 {
 345         struct strbuf buf = STRBUF_INIT;
 346
 347         strbuf_branchname(&buf, branch->name);
 348         if (strcmp(buf.buf, branch->name))
 349                 branch->name = xstrdup(buf.buf);
 350         strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 351         branch->path = strbuf_detach(&buf, NULL);
 352 }
 353
 354 static int merge_working_tree(struct checkout_opts *opts,
 355                               struct branch_info *old, struct branch_info *new)
 356 {
 357         int ret;
 358         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 359         int newfd = hold_locked_index(lock_file, 1);
 360
 361         if (read_cache_preload(NULL) < 0)
 362                 return error("corrupt index file");
 363
 364         resolve_undo_clear();
 365         if (opts->force) {
 366                 ret = reset_tree(new->commit->tree, opts, 1);
 367                 if (ret)
 368                         return ret;
 369         } else {
 370                 struct tree_desc trees[2];
 371                 struct tree *tree;
 372                 struct unpack_trees_options topts;
 373
 374                 memset(&topts, 0, sizeof(topts));
 375                 topts.head_idx = -1;
 376                 topts.src_index = &the_index;
 377                 topts.dst_index = &the_index;
 378
 379                 topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
 380
 381                 refresh_cache(REFRESH_QUIET);
 382
 383                 if (unmerged_cache()) {
 384                         error("you need to resolve your current index first");
 385                         return 1;
 386                 }
 387
 388                 /* 2-way merge to the new branch */
 389                 topts.initial_checkout = is_cache_unborn();
 390                 topts.update = 1;
 391                 topts.merge = 1;
 392                 topts.gently = opts->merge && old->commit;
 393                 topts.verbose_update = !opts->quiet;
 394                 topts.fn = twoway_merge;
 395                 topts.dir = xcalloc(1, sizeof(*topts.dir));
 396                 topts.dir->flags |= DIR_SHOW_IGNORED;
 397                 topts.dir->exclude_per_dir = ".gitignore";
 398                 tree = parse_tree_indirect(old->commit ?
 399                                            old->commit->object.sha1 :
 400                                            (unsigned char *)EMPTY_TREE_SHA1_BIN);
 401                 init_tree_desc(&trees[0], tree->buffer, tree->size);
 402                 tree = parse_tree_indirect(new->commit->object.sha1);
 403                 init_tree_desc(&trees[1], tree->buffer, tree->size);
 404
 405                 ret = unpack_trees(2, trees, &topts);
 406                 if (ret == -1) {
 407                         /*
 408                          * Unpack couldn't do a trivial merge; either
 409                          * give up or do a real merge, depending on
 410                          * whether the merge flag was used.
 411                          */
 412                         struct tree *result;
 413                         struct tree *work;
 414                         struct merge_options o;
 415                         if (!opts->merge)
 416                                 return 1;
 417
 418                         /*
 419                          * Without old->commit, the below is the same as
 420                          * the two-tree unpack we already tried and failed.
 421                          */
 422                         if (!old->commit)
 423                                 return 1;
 424
 425                         /* Do more real merge */
 426
 427                         /*
 428                          * We update the index fully, then write the
 429                          * tree from the index, then merge the new
 430                          * branch with the current tree, with the old
 431                          * branch as the base. Then we reset the index
 432                          * (but not the working tree) to the new
 433                          * branch, leaving the working tree as the
 434                          * merged version, but skipping unmerged
 435                          * entries in the index.
 436                          */
 437
 438                         add_files_to_cache(NULL, NULL, 0);
 439                         init_merge_options(&o);
 440                         o.verbosity = 0;
 441                         work = write_tree_from_memory(&o);
 442
 443                         ret = reset_tree(new->commit->tree, opts, 1);
 444                         if (ret)
 445                                 return ret;
 446                         o.ancestor = old->name;
 447                         o.branch1 = new->name;
 448                         o.branch2 = "local";
 449                         merge_trees(&o, new->commit->tree, work,
 450                                 old->commit->tree, &result);
 451                         ret = reset_tree(new->commit->tree, opts, 0);
 452                         if (ret)
 453                                 return ret;
 454                 }
 455         }
 456
 457         if (write_cache(newfd, active_cache, active_nr) ||
 458             commit_locked_index(lock_file))
 459                 die("unable to write new index file");
 460
 461         if (!opts->force && !opts->quiet)
 462                 show_local_changes(&new->commit->object);
 463
 464         return 0;
 465 }
 466
 467 static void report_tracking(struct branch_info *new)
 468 {
 469         struct strbuf sb = STRBUF_INIT;
 470         struct branch *branch = branch_get(new->name);
 471
 472         if (!format_tracking_info(branch, &sb))
 473                 return;
 474         fputs(sb.buf, stdout);
 475         strbuf_release(&sb);
 476 }
 477
 478 static void detach_advice(const char *old_path, const char *new_name)
 479 {
 480         const char fmt[] =
 481         "Note: checking out '%s'.\n\n"
 482         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 483         "changes and commit them, and you can discard any commits you make in this\n"
 484         "state without impacting any branches by performing another checkout.\n\n"
 485         "If you want to create a new branch to retain commits you create, you may\n"
 486         "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 487         "  git checkout -b new_branch_name\n\n";
 488
 489         fprintf(stderr, fmt, new_name);
 490 }
 491
 492 static void update_refs_for_switch(struct checkout_opts *opts,
 493                                    struct branch_info *old,
 494                                    struct branch_info *new)
 495 {
 496         struct strbuf msg = STRBUF_INIT;
 497         const char *old_desc;
 498         if (opts->new_branch) {
 499                 if (opts->new_orphan_branch) {
 500                         if (opts->new_branch_log && !log_all_ref_updates) {
 501                                 int temp;
 502                                 char log_file[PATH_MAX];
 503                                 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
 504
 505                                 temp = log_all_ref_updates;
 506                                 log_all_ref_updates = 1;
 507                                 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
 508                                         fprintf(stderr, "Can not do reflog for '%s'\n",
 509                                             opts->new_orphan_branch);
 510                                         log_all_ref_updates = temp;
 511                                         return;
 512                                 }
 513                                 log_all_ref_updates = temp;
 514                         }
 515                 }
 516                 else
 517                         create_branch(old->name, opts->new_branch, new->name,
 518                                       opts->new_branch_force ? 1 : 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->branch_exists ? " and reset" : " 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, "branch",
 665                            "create and checkout a new branch"),
 666                 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 667                            "create/reset and checkout a branch"),
 668                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 669                 OPT_SET_INT('t', "track",  &opts.track, "track",
 670                         BRANCH_TRACK_EXPLICIT),
 671                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 672                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 673                             2),
 674                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 675                             3),
 676                 OPT_BOOLEAN('f', "force", &opts.force, "force"),
 677                 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 678                 OPT_STRING(0, "conflict", &conflict_style, "style",
 679                            "conflict style (merge or diff3)"),
 680                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 681                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 682                   "second guess 'git checkout no-such-branch'",
 683                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 684                 OPT_END(),
 685         };
 686         int has_dash_dash;
 687
 688         memset(&opts, 0, sizeof(opts));
 689         memset(&new, 0, sizeof(new));
 690
 691         git_config(git_checkout_config, NULL);
 692
 693         opts.track = BRANCH_TRACK_UNSPECIFIED;
 694
 695         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 696                              PARSE_OPT_KEEP_DASHDASH);
 697
 698         /* we can assume from now on new_branch = !new_branch_force */
 699         if (opts.new_branch && opts.new_branch_force)
 700                 die("-B cannot be used with -b");
 701
 702         /* copy -B over to -b, so that we can just check the latter */
 703         if (opts.new_branch_force)
 704                 opts.new_branch = opts.new_branch_force;
 705
 706         if (patch_mode && (opts.track > 0 || opts.new_branch
 707                            || opts.new_branch_log || opts.merge || opts.force))
 708                 die ("--patch is incompatible with all other options");
 709
 710         /* --track without -b should DWIM */
 711         if (0 < opts.track && !opts.new_branch) {
 712                 const char *argv0 = argv[0];
 713                 if (!argc || !strcmp(argv0, "--"))
 714                         die ("--track needs a branch name");
 715                 if (!prefixcmp(argv0, "refs/"))
 716                         argv0 += 5;
 717                 if (!prefixcmp(argv0, "remotes/"))
 718                         argv0 += 8;
 719                 argv0 = strchr(argv0, '/');
 720                 if (!argv0 || !argv0[1])
 721                         die ("Missing branch name; try -b");
 722                 opts.new_branch = argv0 + 1;
 723         }
 724
 725         if (opts.new_orphan_branch) {
 726                 if (opts.new_branch)
 727                         die("--orphan and -b|-B are mutually exclusive");
 728                 if (opts.track > 0)
 729                         die("--orphan cannot be used with -t");
 730                 opts.new_branch = opts.new_orphan_branch;
 731         }
 732
 733         if (conflict_style) {
 734                 opts.merge = 1; /* implied */
 735                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 736         }
 737
 738         if (opts.force && opts.merge)
 739                 die("git checkout: -f and -m are incompatible");
 740
 741         /*
 742          * case 1: git checkout <ref> -- [<paths>]
 743          *
 744          *   <ref> must be a valid tree, everything after the '--' must be
 745          *   a path.
 746          *
 747          * case 2: git checkout -- [<paths>]
 748          *
 749          *   everything after the '--' must be paths.
 750          *
 751          * case 3: git checkout <something> [<paths>]
 752          *
 753          *   With no paths, if <something> is a commit, that is to
 754          *   switch to the branch or detach HEAD at it.  As a special case,
 755          *   if <something> is A...B (missing A or B means HEAD but you can
 756          *   omit at most one side), and if there is a unique merge base
 757          *   between A and B, A...B names that merge base.
 758          *
 759          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 760          *   was given, and there is a tracking branch whose name is
 761          *   <something> in one and only one remote, then this is a short-hand
 762          *   to fork local <something> from that remote tracking branch.
 763          *
 764          *   Otherwise <something> shall not be ambiguous.
 765          *   - If it's *only* a reference, treat it like case (1).
 766          *   - If it's only a path, treat it like case (2).
 767          *   - else: fail.
 768          *
 769          */
 770         if (argc) {
 771                 if (!strcmp(argv[0], "--")) {       /* case (2) */
 772                         argv++;
 773                         argc--;
 774                         goto no_reference;
 775                 }
 776
 777                 arg = argv[0];
 778                 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 779
 780                 if (!strcmp(arg, "-"))
 781                         arg = "@{-1}";
 782
 783                 if (get_sha1_mb(arg, rev)) {
 784                         if (has_dash_dash)          /* case (1) */
 785                                 die("invalid reference: %s", arg);
 786                         if (!patch_mode &&
 787                             dwim_new_local_branch &&
 788                             opts.track == BRANCH_TRACK_UNSPECIFIED &&
 789                             !opts.new_branch &&
 790                             !check_filename(NULL, arg) &&
 791                             argc == 1) {
 792                                 const char *remote = unique_tracking_name(arg);
 793                                 if (!remote || get_sha1(remote, rev))
 794                                         goto no_reference;
 795                                 opts.new_branch = arg;
 796                                 arg = remote;
 797                                 /* DWIMmed to create local branch */
 798                         }
 799                         else
 800                                 goto no_reference;
 801                 }
 802
 803                 /* we can't end up being in (2) anymore, eat the argument */
 804                 argv++;
 805                 argc--;
 806
 807                 new.name = arg;
 808                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 809                         setup_branch_path(&new);
 810
 811                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 812                             resolve_ref(new.path, rev, 1, NULL))
 813                                 ;
 814                         else
 815                                 new.path = NULL;
 816                         parse_commit(new.commit);
 817                         source_tree = new.commit->tree;
 818                 } else
 819                         source_tree = parse_tree_indirect(rev);
 820
 821                 if (!source_tree)                   /* case (1): want a tree */
 822                         die("reference is not a tree: %s", arg);
 823                 if (!has_dash_dash) {/* case (3 -> 1) */
 824                         /*
 825                          * Do not complain the most common case
 826                          *      git checkout branch
 827                          * even if there happen to be a file called 'branch';
 828                          * it would be extremely annoying.
 829                          */
 830                         if (argc)
 831                                 verify_non_filename(NULL, arg);
 832                 }
 833                 else {
 834                         argv++;
 835                         argc--;
 836                 }
 837         }
 838
 839 no_reference:
 840
 841         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 842                 opts.track = git_branch_track;
 843
 844         if (argc) {
 845                 const char **pathspec = get_pathspec(prefix, argv);
 846
 847                 if (!pathspec)
 848                         die("invalid path specification");
 849
 850                 if (patch_mode)
 851                         return interactive_checkout(new.name, pathspec, &opts);
 852
 853                 /* Checkout paths */
 854                 if (opts.new_branch) {
 855                         if (argc == 1) {
 856                                 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]);
 857                         } else {
 858                                 die("git checkout: updating paths is incompatible with switching branches.");
 859                         }
 860                 }
 861
 862                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 863                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 864
 865                 return checkout_paths(source_tree, pathspec, &opts);
 866         }
 867
 868         if (patch_mode)
 869                 return interactive_checkout(new.name, NULL, &opts);
 870
 871         if (opts.new_branch) {
 872                 struct strbuf buf = STRBUF_INIT;
 873                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 874                         die("git checkout: we do not like '%s' as a branch name.",
 875                             opts.new_branch);
 876                 if (!get_sha1(buf.buf, rev)) {
 877                         opts.branch_exists = 1;
 878                         if (!opts.new_branch_force)
 879                                 die("git checkout: branch %s already exists",
 880                                     opts.new_branch);
 881                 }
 882                 strbuf_release(&buf);
 883         }
 884
 885         if (new.name && !new.commit) {
 886                 die("Cannot switch branch to a non-commit.");
 887         }
 888         if (opts.writeout_stage)
 889                 die("--ours/--theirs is incompatible with switching branches.");
 890
 891         return switch_branches(&opts, &new);
 892 }