builtin/checkout.c

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