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