git.oblomov.eu Git - git/blob - 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         int new_branch_log;
  37         enum branch_track track;
  38 };
  39
  40 static int post_checkout_hook(struct commit *old, struct commit *new,
  41                               int changed)
  42 {
  43         return run_hook(NULL, "post-checkout",
  44                         sha1_to_hex(old ? old->object.sha1 : null_sha1),
  45                         sha1_to_hex(new ? new->object.sha1 : null_sha1),
  46                         changed ? "1" : "0", NULL);
  47         /* "new" can be NULL when checking out from the index before
  48            a commit exists. */
  49
  50 }
  51
  52 static int update_some(const unsigned char *sha1, const char *base, int baselen,
  53                 const char *pathname, unsigned mode, int stage, void *context)
  54 {
  55         int len;
  56         struct cache_entry *ce;
  57
  58         if (S_ISDIR(mode))
  59                 return READ_TREE_RECURSIVE;
  60
  61         len = baselen + strlen(pathname);
  62         ce = xcalloc(1, cache_entry_size(len));
  63         hashcpy(ce->sha1, sha1);
  64         memcpy(ce->name, base, baselen);
  65         memcpy(ce->name + baselen, pathname, len - baselen);
  66         ce->ce_flags = create_ce_flags(len, 0);
  67         ce->ce_mode = create_ce_mode(mode);
  68         add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
  69         return 0;
  70 }
  71
  72 static int read_tree_some(struct tree *tree, const char **pathspec)
  73 {
  74         read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
  75
  76         /* update the index with the given tree's info
  77          * for all args, expanding wildcards, and exit
  78          * with any non-zero return code.
  79          */
  80         return 0;
  81 }
  82
  83 static int skip_same_name(struct cache_entry *ce, int pos)
  84 {
  85         while (++pos < active_nr &&
  86                !strcmp(active_cache[pos]->name, ce->name))
  87                 ; /* skip */
  88         return pos;
  89 }
  90
  91 static int check_stage(int stage, struct cache_entry *ce, int pos)
  92 {
  93         while (pos < active_nr &&
  94                !strcmp(active_cache[pos]->name, ce->name)) {
  95                 if (ce_stage(active_cache[pos]) == stage)
  96                         return 0;
  97                 pos++;
  98         }
  99         return error("path '%s' does not have %s version",
 100                      ce->name,
 101                      (stage == 2) ? "our" : "their");
 102 }
 103
 104 static int check_all_stages(struct cache_entry *ce, int pos)
 105 {
 106         if (ce_stage(ce) != 1 ||
 107             active_nr <= pos + 2 ||
 108             strcmp(active_cache[pos+1]->name, ce->name) ||
 109             ce_stage(active_cache[pos+1]) != 2 ||
 110             strcmp(active_cache[pos+2]->name, ce->name) ||
 111             ce_stage(active_cache[pos+2]) != 3)
 112                 return error("path '%s' does not have all three versions",
 113                              ce->name);
 114         return 0;
 115 }
 116
 117 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 118                           struct checkout *state)
 119 {
 120         while (pos < active_nr &&
 121                !strcmp(active_cache[pos]->name, ce->name)) {
 122                 if (ce_stage(active_cache[pos]) == stage)
 123                         return checkout_entry(active_cache[pos], state, NULL);
 124                 pos++;
 125         }
 126         return error("path '%s' does not have %s version",
 127                      ce->name,
 128                      (stage == 2) ? "our" : "their");
 129 }
 130
 131 static int checkout_merged(int pos, struct checkout *state)
 132 {
 133         struct cache_entry *ce = active_cache[pos];
 134         const char *path = ce->name;
 135         mmfile_t ancestor, ours, theirs;
 136         int status;
 137         unsigned char sha1[20];
 138         mmbuffer_t result_buf;
 139
 140         if (ce_stage(ce) != 1 ||
 141             active_nr <= pos + 2 ||
 142             strcmp(active_cache[pos+1]->name, path) ||
 143             ce_stage(active_cache[pos+1]) != 2 ||
 144             strcmp(active_cache[pos+2]->name, path) ||
 145             ce_stage(active_cache[pos+2]) != 3)
 146                 return error("path '%s' does not have all 3 versions", path);
 147
 148         read_mmblob(&ancestor, active_cache[pos]->sha1);
 149         read_mmblob(&ours, active_cache[pos+1]->sha1);
 150         read_mmblob(&theirs, active_cache[pos+2]->sha1);
 151
 152         status = ll_merge(&result_buf, path, &ancestor, "base",
 153                           &ours, "ours", &theirs, "theirs", 0);
 154         free(ancestor.ptr);
 155         free(ours.ptr);
 156         free(theirs.ptr);
 157         if (status < 0 || !result_buf.ptr) {
 158                 free(result_buf.ptr);
 159                 return error("path '%s': cannot merge", path);
 160         }
 161
 162         /*
 163          * NEEDSWORK:
 164          * There is absolutely no reason to write this as a blob object
 165          * and create a phony cache entry just to leak.  This hack is
 166          * primarily to get to the write_entry() machinery that massages
 167          * the contents to work-tree format and writes out which only
 168          * allows it for a cache entry.  The code in write_entry() needs
 169          * to be refactored to allow us to feed a <buffer, size, mode>
 170          * instead of a cache entry.  Such a refactoring would help
 171          * merge_recursive as well (it also writes the merge result to the
 172          * object database even when it may contain conflicts).
 173          */
 174         if (write_sha1_file(result_buf.ptr, result_buf.size,
 175                             blob_type, sha1))
 176                 die("Unable to add merge result for '%s'", path);
 177         ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
 178                               sha1,
 179                               path, 2, 0);
 180         if (!ce)
 181                 die("make_cache_entry failed for path '%s'", path);
 182         status = checkout_entry(ce, state, NULL);
 183         return status;
 184 }
 185
 186 static int checkout_paths(struct tree *source_tree, const char **pathspec,
 187                           struct checkout_opts *opts)
 188 {
 189         int pos;
 190         struct checkout state;
 191         static char *ps_matched;
 192         unsigned char rev[20];
 193         int flag;
 194         struct commit *head;
 195         int errs = 0;
 196         int stage = opts->writeout_stage;
 197         int merge = opts->merge;
 198         int newfd;
 199         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 200
 201         newfd = hold_locked_index(lock_file, 1);
 202         if (read_cache_preload(pathspec) < 0)
 203                 return error("corrupt index file");
 204
 205         if (source_tree)
 206                 read_tree_some(source_tree, pathspec);
 207
 208         for (pos = 0; pathspec[pos]; pos++)
 209                 ;
 210         ps_matched = xcalloc(1, pos);
 211
 212         for (pos = 0; pos < active_nr; pos++) {
 213                 struct cache_entry *ce = active_cache[pos];
 214                 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
 215         }
 216
 217         if (report_path_error(ps_matched, pathspec, 0))
 218                 return 1;
 219
 220         /* "checkout -m path" to recreate conflicted state */
 221         if (opts->merge)
 222                 unmerge_cache(pathspec);
 223
 224         /* Any unmerged paths? */
 225         for (pos = 0; pos < active_nr; pos++) {
 226                 struct cache_entry *ce = active_cache[pos];
 227                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 228                         if (!ce_stage(ce))
 229                                 continue;
 230                         if (opts->force) {
 231                                 warning("path '%s' is unmerged", ce->name);
 232                         } else if (stage) {
 233                                 errs |= check_stage(stage, ce, pos);
 234                         } else if (opts->merge) {
 235                                 errs |= check_all_stages(ce, pos);
 236                         } else {
 237                                 errs = 1;
 238                                 error("path '%s' is unmerged", ce->name);
 239                         }
 240                         pos = skip_same_name(ce, pos) - 1;
 241                 }
 242         }
 243         if (errs)
 244                 return 1;
 245
 246         /* Now we are committed to check them out */
 247         memset(&state, 0, sizeof(state));
 248         state.force = 1;
 249         state.refresh_cache = 1;
 250         for (pos = 0; pos < active_nr; pos++) {
 251                 struct cache_entry *ce = active_cache[pos];
 252                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 253                         if (!ce_stage(ce)) {
 254                                 errs |= checkout_entry(ce, &state, NULL);
 255                                 continue;
 256                         }
 257                         if (stage)
 258                                 errs |= checkout_stage(stage, ce, pos, &state);
 259                         else if (merge)
 260                                 errs |= checkout_merged(pos, &state);
 261                         pos = skip_same_name(ce, pos) - 1;
 262                 }
 263         }
 264
 265         if (write_cache(newfd, active_cache, active_nr) ||
 266             commit_locked_index(lock_file))
 267                 die("unable to write new index file");
 268
 269         resolve_ref("HEAD", rev, 0, &flag);
 270         head = lookup_commit_reference_gently(rev, 1);
 271
 272         errs |= post_checkout_hook(head, head, 0);
 273         return errs;
 274 }
 275
 276 static void show_local_changes(struct object *head)
 277 {
 278         struct rev_info rev;
 279         /* I think we want full paths, even if we're in a subdirectory. */
 280         init_revisions(&rev, NULL);
 281         rev.abbrev = 0;
 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                 create_branch(old->name, opts->new_branch, new->name, 0,
 496                               opts->new_branch_log, opts->track);
 497                 new->name = opts->new_branch;
 498                 setup_branch_path(new);
 499         }
 500
 501         old_desc = old->name;
 502         if (!old_desc && old->commit)
 503                 old_desc = sha1_to_hex(old->commit->object.sha1);
 504         strbuf_addf(&msg, "checkout: moving from %s to %s",
 505                     old_desc ? old_desc : "(invalid)", new->name);
 506
 507         if (new->path) {
 508                 create_symref("HEAD", new->path, msg.buf);
 509                 if (!opts->quiet) {
 510                         if (old->path && !strcmp(new->path, old->path))
 511                                 fprintf(stderr, "Already on '%s'\n",
 512                                         new->name);
 513                         else
 514                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 515                                         opts->new_branch ? " a new" : "",
 516                                         new->name);
 517                 }
 518         } else if (strcmp(new->name, "HEAD")) {
 519                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 520                            REF_NODEREF, DIE_ON_ERR);
 521                 if (!opts->quiet) {
 522                         if (old->path && advice_detached_head)
 523                                 detach_advice(old->path, new->name);
 524                         describe_detached_head("HEAD is now at", new->commit);
 525                 }
 526         }
 527         remove_branch_state();
 528         strbuf_release(&msg);
 529         if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 530                 report_tracking(new);
 531 }
 532
 533 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 534 {
 535         int ret = 0;
 536         struct branch_info old;
 537         unsigned char rev[20];
 538         int flag;
 539         memset(&old, 0, sizeof(old));
 540         old.path = resolve_ref("HEAD", rev, 0, &flag);
 541         old.commit = lookup_commit_reference_gently(rev, 1);
 542         if (!(flag & REF_ISSYMREF))
 543                 old.path = NULL;
 544
 545         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 546                 old.name = old.path + strlen("refs/heads/");
 547
 548         if (!new->name) {
 549                 new->name = "HEAD";
 550                 new->commit = old.commit;
 551                 if (!new->commit)
 552                         die("You are on a branch yet to be born");
 553                 parse_commit(new->commit);
 554         }
 555
 556         ret = merge_working_tree(opts, &old, new);
 557         if (ret)
 558                 return ret;
 559
 560         /*
 561          * If we were on a detached HEAD, but have now moved to
 562          * a new commit, we want to mention the old commit once more
 563          * to remind the user that it might be lost.
 564          */
 565         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 566                 describe_detached_head("Previous HEAD position was", old.commit);
 567
 568         update_refs_for_switch(opts, &old, new);
 569
 570         ret = post_checkout_hook(old.commit, new->commit, 1);
 571         return ret || opts->writeout_error;
 572 }
 573
 574 static int git_checkout_config(const char *var, const char *value, void *cb)
 575 {
 576         return git_xmerge_config(var, value, cb);
 577 }
 578
 579 static int interactive_checkout(const char *revision, const char **pathspec,
 580                                 struct checkout_opts *opts)
 581 {
 582         return run_add_interactive(revision, "--patch=checkout", pathspec);
 583 }
 584
 585 struct tracking_name_data {
 586         const char *name;
 587         char *remote;
 588         int unique;
 589 };
 590
 591 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 592                                int flags, void *cb_data)
 593 {
 594         struct tracking_name_data *cb = cb_data;
 595         const char *slash;
 596
 597         if (prefixcmp(refname, "refs/remotes/"))
 598                 return 0;
 599         slash = strchr(refname + 13, '/');
 600         if (!slash || strcmp(slash + 1, cb->name))
 601                 return 0;
 602         if (cb->remote) {
 603                 cb->unique = 0;
 604                 return 0;
 605         }
 606         cb->remote = xstrdup(refname);
 607         return 0;
 608 }
 609
 610 static const char *unique_tracking_name(const char *name)
 611 {
 612         struct tracking_name_data cb_data = { NULL, NULL, 1 };
 613         cb_data.name = name;
 614         for_each_ref(check_tracking_name, &cb_data);
 615         if (cb_data.unique)
 616                 return cb_data.remote;
 617         free(cb_data.remote);
 618         return NULL;
 619 }
 620
 621 int cmd_checkout(int argc, const char **argv, const char *prefix)
 622 {
 623         struct checkout_opts opts;
 624         unsigned char rev[20];
 625         const char *arg;
 626         struct branch_info new;
 627         struct tree *source_tree = NULL;
 628         char *conflict_style = NULL;
 629         int patch_mode = 0;
 630         int dwim_new_local_branch = 1;
 631         struct option options[] = {
 632                 OPT__QUIET(&opts.quiet),
 633                 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
 634                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 635                 OPT_SET_INT('t', "track",  &opts.track, "track",
 636                         BRANCH_TRACK_EXPLICIT),
 637                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 638                             2),
 639                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 640                             3),
 641                 OPT_BOOLEAN('f', "force", &opts.force, "force"),
 642                 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 643                 OPT_STRING(0, "conflict", &conflict_style, "style",
 644                            "conflict style (merge or diff3)"),
 645                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 646                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 647                   "second guess 'git checkout no-such-branch'",
 648                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 649                 OPT_END(),
 650         };
 651         int has_dash_dash;
 652
 653         memset(&opts, 0, sizeof(opts));
 654         memset(&new, 0, sizeof(new));
 655
 656         git_config(git_checkout_config, NULL);
 657
 658         opts.track = BRANCH_TRACK_UNSPECIFIED;
 659
 660         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 661                              PARSE_OPT_KEEP_DASHDASH);
 662
 663         if (patch_mode && (opts.track > 0 || opts.new_branch
 664                            || opts.new_branch_log || opts.merge || opts.force))
 665                 die ("--patch is incompatible with all other options");
 666
 667         /* --track without -b should DWIM */
 668         if (0 < opts.track && !opts.new_branch) {
 669                 const char *argv0 = argv[0];
 670                 if (!argc || !strcmp(argv0, "--"))
 671                         die ("--track needs a branch name");
 672                 if (!prefixcmp(argv0, "refs/"))
 673                         argv0 += 5;
 674                 if (!prefixcmp(argv0, "remotes/"))
 675                         argv0 += 8;
 676                 argv0 = strchr(argv0, '/');
 677                 if (!argv0 || !argv0[1])
 678                         die ("Missing branch name; try -b");
 679                 opts.new_branch = argv0 + 1;
 680         }
 681
 682         if (conflict_style) {
 683                 opts.merge = 1; /* implied */
 684                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 685         }
 686
 687         if (opts.force && opts.merge)
 688                 die("git checkout: -f and -m are incompatible");
 689
 690         /*
 691          * case 1: git checkout <ref> -- [<paths>]
 692          *
 693          *   <ref> must be a valid tree, everything after the '--' must be
 694          *   a path.
 695          *
 696          * case 2: git checkout -- [<paths>]
 697          *
 698          *   everything after the '--' must be paths.
 699          *
 700          * case 3: git checkout <something> [<paths>]
 701          *
 702          *   With no paths, if <something> is a commit, that is to
 703          *   switch to the branch or detach HEAD at it.  As a special case,
 704          *   if <something> is A...B (missing A or B means HEAD but you can
 705          *   omit at most one side), and if there is a unique merge base
 706          *   between A and B, A...B names that merge base.
 707          *
 708          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 709          *   was given, and there is a tracking branch whose name is
 710          *   <something> in one and only one remote, then this is a short-hand
 711          *   to fork local <something> from that remote tracking branch.
 712          *
 713          *   Otherwise <something> shall not be ambiguous.
 714          *   - If it's *only* a reference, treat it like case (1).
 715          *   - If it's only a path, treat it like case (2).
 716          *   - else: fail.
 717          *
 718          */
 719         if (argc) {
 720                 if (!strcmp(argv[0], "--")) {       /* case (2) */
 721                         argv++;
 722                         argc--;
 723                         goto no_reference;
 724                 }
 725
 726                 arg = argv[0];
 727                 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 728
 729                 if (!strcmp(arg, "-"))
 730                         arg = "@{-1}";
 731
 732                 if (get_sha1_mb(arg, rev)) {
 733                         if (has_dash_dash)          /* case (1) */
 734                                 die("invalid reference: %s", arg);
 735                         if (!patch_mode &&
 736                             dwim_new_local_branch &&
 737                             opts.track == BRANCH_TRACK_UNSPECIFIED &&
 738                             !opts.new_branch &&
 739                             !check_filename(NULL, arg) &&
 740                             argc == 1) {
 741                                 const char *remote = unique_tracking_name(arg);
 742                                 if (!remote || get_sha1(remote, rev))
 743                                         goto no_reference;
 744                                 opts.new_branch = arg;
 745                                 arg = remote;
 746                                 /* DWIMmed to create local branch */
 747                         }
 748                         else
 749                                 goto no_reference;
 750                 }
 751
 752                 /* we can't end up being in (2) anymore, eat the argument */
 753                 argv++;
 754                 argc--;
 755
 756                 new.name = arg;
 757                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 758                         setup_branch_path(&new);
 759
 760                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 761                             resolve_ref(new.path, rev, 1, NULL))
 762                                 ;
 763                         else
 764                                 new.path = NULL;
 765                         parse_commit(new.commit);
 766                         source_tree = new.commit->tree;
 767                 } else
 768                         source_tree = parse_tree_indirect(rev);
 769
 770                 if (!source_tree)                   /* case (1): want a tree */
 771                         die("reference is not a tree: %s", arg);
 772                 if (!has_dash_dash) {/* case (3 -> 1) */
 773                         /*
 774                          * Do not complain the most common case
 775                          *      git checkout branch
 776                          * even if there happen to be a file called 'branch';
 777                          * it would be extremely annoying.
 778                          */
 779                         if (argc)
 780                                 verify_non_filename(NULL, arg);
 781                 }
 782                 else {
 783                         argv++;
 784                         argc--;
 785                 }
 786         }
 787
 788 no_reference:
 789
 790         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 791                 opts.track = git_branch_track;
 792
 793         if (argc) {
 794                 const char **pathspec = get_pathspec(prefix, argv);
 795
 796                 if (!pathspec)
 797                         die("invalid path specification");
 798
 799                 if (patch_mode)
 800                         return interactive_checkout(new.name, pathspec, &opts);
 801
 802                 /* Checkout paths */
 803                 if (opts.new_branch) {
 804                         if (argc == 1) {
 805                                 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]);
 806                         } else {
 807                                 die("git checkout: updating paths is incompatible with switching branches.");
 808                         }
 809                 }
 810
 811                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 812                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 813
 814                 return checkout_paths(source_tree, pathspec, &opts);
 815         }
 816
 817         if (patch_mode)
 818                 return interactive_checkout(new.name, NULL, &opts);
 819
 820         if (opts.new_branch) {
 821                 struct strbuf buf = STRBUF_INIT;
 822                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 823                         die("git checkout: we do not like '%s' as a branch name.",
 824                             opts.new_branch);
 825                 if (!get_sha1(buf.buf, rev))
 826                         die("git checkout: branch %s already exists", opts.new_branch);
 827                 strbuf_release(&buf);
 828         }
 829
 830         if (new.name && !new.commit) {
 831                 die("Cannot switch branch to a non-commit.");
 832         }
 833         if (opts.writeout_stage)
 834                 die("--ours/--theirs is incompatible with switching branches.");
 835
 836         return switch_branches(&opts, &new);
 837 }