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