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