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