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 if (opts->new_branch)
 537                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 538                                         opts->branch_exists ? " and reset" : " a new",
 539                                         new->name);
 540                         else
 541                                 fprintf(stderr, "Switched to branch '%s'\n",
 542                                         new->name);
 543                 }
 544                 if (old->path && old->name) {
 545                         char log_file[PATH_MAX], ref_file[PATH_MAX];
 546
 547                         git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 548                         git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 549                         if (!file_exists(ref_file) && file_exists(log_file))
 550                                 remove_path(log_file);
 551                 }
 552         } else if (strcmp(new->name, "HEAD")) {
 553                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 554                            REF_NODEREF, DIE_ON_ERR);
 555                 if (!opts->quiet) {
 556                         if (old->path && advice_detached_head)
 557                                 detach_advice(old->path, new->name);
 558                         describe_detached_head("HEAD is now at", new->commit);
 559                 }
 560         }
 561         remove_branch_state();
 562         strbuf_release(&msg);
 563         if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 564                 report_tracking(new);
 565 }
 566
 567 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 568 {
 569         int ret = 0;
 570         struct branch_info old;
 571         unsigned char rev[20];
 572         int flag;
 573         memset(&old, 0, sizeof(old));
 574         old.path = resolve_ref("HEAD", rev, 0, &flag);
 575         old.commit = lookup_commit_reference_gently(rev, 1);
 576         if (!(flag & REF_ISSYMREF))
 577                 old.path = NULL;
 578
 579         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 580                 old.name = old.path + strlen("refs/heads/");
 581
 582         if (!new->name) {
 583                 new->name = "HEAD";
 584                 new->commit = old.commit;
 585                 if (!new->commit)
 586                         die("You are on a branch yet to be born");
 587                 parse_commit(new->commit);
 588         }
 589
 590         ret = merge_working_tree(opts, &old, new);
 591         if (ret)
 592                 return ret;
 593
 594         /*
 595          * If we were on a detached HEAD, but have now moved to
 596          * a new commit, we want to mention the old commit once more
 597          * to remind the user that it might be lost.
 598          */
 599         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 600                 describe_detached_head("Previous HEAD position was", old.commit);
 601
 602         update_refs_for_switch(opts, &old, new);
 603
 604         ret = post_checkout_hook(old.commit, new->commit, 1);
 605         return ret || opts->writeout_error;
 606 }
 607
 608 static int git_checkout_config(const char *var, const char *value, void *cb)
 609 {
 610         return git_xmerge_config(var, value, cb);
 611 }
 612
 613 static int interactive_checkout(const char *revision, const char **pathspec,
 614                                 struct checkout_opts *opts)
 615 {
 616         return run_add_interactive(revision, "--patch=checkout", pathspec);
 617 }
 618
 619 struct tracking_name_data {
 620         const char *name;
 621         char *remote;
 622         int unique;
 623 };
 624
 625 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 626                                int flags, void *cb_data)
 627 {
 628         struct tracking_name_data *cb = cb_data;
 629         const char *slash;
 630
 631         if (prefixcmp(refname, "refs/remotes/"))
 632                 return 0;
 633         slash = strchr(refname + 13, '/');
 634         if (!slash || strcmp(slash + 1, cb->name))
 635                 return 0;
 636         if (cb->remote) {
 637                 cb->unique = 0;
 638                 return 0;
 639         }
 640         cb->remote = xstrdup(refname);
 641         return 0;
 642 }
 643
 644 static const char *unique_tracking_name(const char *name)
 645 {
 646         struct tracking_name_data cb_data = { NULL, NULL, 1 };
 647         cb_data.name = name;
 648         for_each_ref(check_tracking_name, &cb_data);
 649         if (cb_data.unique)
 650                 return cb_data.remote;
 651         free(cb_data.remote);
 652         return NULL;
 653 }
 654
 655 int cmd_checkout(int argc, const char **argv, const char *prefix)
 656 {
 657         struct checkout_opts opts;
 658         unsigned char rev[20];
 659         const char *arg;
 660         struct branch_info new;
 661         struct tree *source_tree = NULL;
 662         char *conflict_style = NULL;
 663         int patch_mode = 0;
 664         int dwim_new_local_branch = 1;
 665         struct option options[] = {
 666                 OPT__QUIET(&opts.quiet),
 667                 OPT_STRING('b', NULL, &opts.new_branch, "branch",
 668                            "create and checkout a new branch"),
 669                 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 670                            "create/reset and checkout a branch"),
 671                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 672                 OPT_SET_INT('t', "track",  &opts.track, "track",
 673                         BRANCH_TRACK_EXPLICIT),
 674                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 675                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 676                             2),
 677                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 678                             3),
 679                 OPT_BOOLEAN('f', "force", &opts.force, "force"),
 680                 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 681                 OPT_STRING(0, "conflict", &conflict_style, "style",
 682                            "conflict style (merge or diff3)"),
 683                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 684                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 685                   "second guess 'git checkout no-such-branch'",
 686                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 687                 OPT_END(),
 688         };
 689         int has_dash_dash;
 690
 691         memset(&opts, 0, sizeof(opts));
 692         memset(&new, 0, sizeof(new));
 693
 694         git_config(git_checkout_config, NULL);
 695
 696         opts.track = BRANCH_TRACK_UNSPECIFIED;
 697
 698         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 699                              PARSE_OPT_KEEP_DASHDASH);
 700
 701         /* we can assume from now on new_branch = !new_branch_force */
 702         if (opts.new_branch && opts.new_branch_force)
 703                 die("-B cannot be used with -b");
 704
 705         /* copy -B over to -b, so that we can just check the latter */
 706         if (opts.new_branch_force)
 707                 opts.new_branch = opts.new_branch_force;
 708
 709         if (patch_mode && (opts.track > 0 || opts.new_branch
 710                            || opts.new_branch_log || opts.merge || opts.force))
 711                 die ("--patch is incompatible with all other options");
 712
 713         /* --track without -b should DWIM */
 714         if (0 < opts.track && !opts.new_branch) {
 715                 const char *argv0 = argv[0];
 716                 if (!argc || !strcmp(argv0, "--"))
 717                         die ("--track needs a branch name");
 718                 if (!prefixcmp(argv0, "refs/"))
 719                         argv0 += 5;
 720                 if (!prefixcmp(argv0, "remotes/"))
 721                         argv0 += 8;
 722                 argv0 = strchr(argv0, '/');
 723                 if (!argv0 || !argv0[1])
 724                         die ("Missing branch name; try -b");
 725                 opts.new_branch = argv0 + 1;
 726         }
 727
 728         if (opts.new_orphan_branch) {
 729                 if (opts.new_branch)
 730                         die("--orphan and -b|-B are mutually exclusive");
 731                 if (opts.track > 0)
 732                         die("--orphan cannot be used with -t");
 733                 opts.new_branch = opts.new_orphan_branch;
 734         }
 735
 736         if (conflict_style) {
 737                 opts.merge = 1; /* implied */
 738                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 739         }
 740
 741         if (opts.force && opts.merge)
 742                 die("git checkout: -f and -m are incompatible");
 743
 744         /*
 745          * case 1: git checkout <ref> -- [<paths>]
 746          *
 747          *   <ref> must be a valid tree, everything after the '--' must be
 748          *   a path.
 749          *
 750          * case 2: git checkout -- [<paths>]
 751          *
 752          *   everything after the '--' must be paths.
 753          *
 754          * case 3: git checkout <something> [<paths>]
 755          *
 756          *   With no paths, if <something> is a commit, that is to
 757          *   switch to the branch or detach HEAD at it.  As a special case,
 758          *   if <something> is A...B (missing A or B means HEAD but you can
 759          *   omit at most one side), and if there is a unique merge base
 760          *   between A and B, A...B names that merge base.
 761          *
 762          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 763          *   was given, and there is a tracking branch whose name is
 764          *   <something> in one and only one remote, then this is a short-hand
 765          *   to fork local <something> from that remote tracking branch.
 766          *
 767          *   Otherwise <something> shall not be ambiguous.
 768          *   - If it's *only* a reference, treat it like case (1).
 769          *   - If it's only a path, treat it like case (2).
 770          *   - else: fail.
 771          *
 772          */
 773         if (argc) {
 774                 if (!strcmp(argv[0], "--")) {       /* case (2) */
 775                         argv++;
 776                         argc--;
 777                         goto no_reference;
 778                 }
 779
 780                 arg = argv[0];
 781                 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 782
 783                 if (!strcmp(arg, "-"))
 784                         arg = "@{-1}";
 785
 786                 if (get_sha1_mb(arg, rev)) {
 787                         if (has_dash_dash)          /* case (1) */
 788                                 die("invalid reference: %s", arg);
 789                         if (!patch_mode &&
 790                             dwim_new_local_branch &&
 791                             opts.track == BRANCH_TRACK_UNSPECIFIED &&
 792                             !opts.new_branch &&
 793                             !check_filename(NULL, arg) &&
 794                             argc == 1) {
 795                                 const char *remote = unique_tracking_name(arg);
 796                                 if (!remote || get_sha1(remote, rev))
 797                                         goto no_reference;
 798                                 opts.new_branch = arg;
 799                                 arg = remote;
 800                                 /* DWIMmed to create local branch */
 801                         }
 802                         else
 803                                 goto no_reference;
 804                 }
 805
 806                 /* we can't end up being in (2) anymore, eat the argument */
 807                 argv++;
 808                 argc--;
 809
 810                 new.name = arg;
 811                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 812                         setup_branch_path(&new);
 813
 814                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 815                             resolve_ref(new.path, rev, 1, NULL))
 816                                 ;
 817                         else
 818                                 new.path = NULL;
 819                         parse_commit(new.commit);
 820                         source_tree = new.commit->tree;
 821                 } else
 822                         source_tree = parse_tree_indirect(rev);
 823
 824                 if (!source_tree)                   /* case (1): want a tree */
 825                         die("reference is not a tree: %s", arg);
 826                 if (!has_dash_dash) {/* case (3 -> 1) */
 827                         /*
 828                          * Do not complain the most common case
 829                          *      git checkout branch
 830                          * even if there happen to be a file called 'branch';
 831                          * it would be extremely annoying.
 832                          */
 833                         if (argc)
 834                                 verify_non_filename(NULL, arg);
 835                 }
 836                 else {
 837                         argv++;
 838                         argc--;
 839                 }
 840         }
 841
 842 no_reference:
 843
 844         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 845                 opts.track = git_branch_track;
 846
 847         if (argc) {
 848                 const char **pathspec = get_pathspec(prefix, argv);
 849
 850                 if (!pathspec)
 851                         die("invalid path specification");
 852
 853                 if (patch_mode)
 854                         return interactive_checkout(new.name, pathspec, &opts);
 855
 856                 /* Checkout paths */
 857                 if (opts.new_branch) {
 858                         if (argc == 1) {
 859                                 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]);
 860                         } else {
 861                                 die("git checkout: updating paths is incompatible with switching branches.");
 862                         }
 863                 }
 864
 865                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 866                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 867
 868                 return checkout_paths(source_tree, pathspec, &opts);
 869         }
 870
 871         if (patch_mode)
 872                 return interactive_checkout(new.name, NULL, &opts);
 873
 874         if (opts.new_branch) {
 875                 struct strbuf buf = STRBUF_INIT;
 876                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 877                         die("git checkout: we do not like '%s' as a branch name.",
 878                             opts.new_branch);
 879                 if (!get_sha1(buf.buf, rev)) {
 880                         opts.branch_exists = 1;
 881                         if (!opts.new_branch_force)
 882                                 die("git checkout: branch %s already exists",
 883                                     opts.new_branch);
 884                 }
 885                 strbuf_release(&buf);
 886         }
 887
 888         if (new.name && !new.commit) {
 889                 die("Cannot switch branch to a non-commit.");
 890         }
 891         if (opts.writeout_stage)
 892                 die("--ours/--theirs is incompatible with switching branches.");
 893
 894         return switch_branches(&opts, &new);
 895 }