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         if (stage == 2)
 107                 return error(_("path '%s' does not have our version"), ce->name);
 108         else
 109                 return error(_("path '%s' does not have their version"), ce->name);
 110 }
 111
 112 static int check_all_stages(struct cache_entry *ce, int pos)
 113 {
 114         if (ce_stage(ce) != 1 ||
 115             active_nr <= pos + 2 ||
 116             strcmp(active_cache[pos+1]->name, ce->name) ||
 117             ce_stage(active_cache[pos+1]) != 2 ||
 118             strcmp(active_cache[pos+2]->name, ce->name) ||
 119             ce_stage(active_cache[pos+2]) != 3)
 120                 return error(_("path '%s' does not have all three versions"),
 121                              ce->name);
 122         return 0;
 123 }
 124
 125 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 126                           struct checkout *state)
 127 {
 128         while (pos < active_nr &&
 129                !strcmp(active_cache[pos]->name, ce->name)) {
 130                 if (ce_stage(active_cache[pos]) == stage)
 131                         return checkout_entry(active_cache[pos], state, NULL);
 132                 pos++;
 133         }
 134         if (stage == 2)
 135                 return error(_("path '%s' does not have our version"), ce->name);
 136         else
 137                 return error(_("path '%s' does not have their version"), ce->name);
 138 }
 139
 140 static int checkout_merged(int pos, struct checkout *state)
 141 {
 142         struct cache_entry *ce = active_cache[pos];
 143         const char *path = ce->name;
 144         mmfile_t ancestor, ours, theirs;
 145         int status;
 146         unsigned char sha1[20];
 147         mmbuffer_t result_buf;
 148
 149         if (ce_stage(ce) != 1 ||
 150             active_nr <= pos + 2 ||
 151             strcmp(active_cache[pos+1]->name, path) ||
 152             ce_stage(active_cache[pos+1]) != 2 ||
 153             strcmp(active_cache[pos+2]->name, path) ||
 154             ce_stage(active_cache[pos+2]) != 3)
 155                 return error(_("path '%s' does not have all 3 versions"), path);
 156
 157         read_mmblob(&ancestor, active_cache[pos]->sha1);
 158         read_mmblob(&ours, active_cache[pos+1]->sha1);
 159         read_mmblob(&theirs, active_cache[pos+2]->sha1);
 160
 161         /*
 162          * NEEDSWORK: re-create conflicts from merges with
 163          * merge.renormalize set, too
 164          */
 165         status = ll_merge(&result_buf, path, &ancestor, "base",
 166                           &ours, "ours", &theirs, "theirs", NULL);
 167         free(ancestor.ptr);
 168         free(ours.ptr);
 169         free(theirs.ptr);
 170         if (status < 0 || !result_buf.ptr) {
 171                 free(result_buf.ptr);
 172                 return error(_("path '%s': cannot merge"), path);
 173         }
 174
 175         /*
 176          * NEEDSWORK:
 177          * There is absolutely no reason to write this as a blob object
 178          * and create a phony cache entry just to leak.  This hack is
 179          * primarily to get to the write_entry() machinery that massages
 180          * the contents to work-tree format and writes out which only
 181          * allows it for a cache entry.  The code in write_entry() needs
 182          * to be refactored to allow us to feed a <buffer, size, mode>
 183          * instead of a cache entry.  Such a refactoring would help
 184          * merge_recursive as well (it also writes the merge result to the
 185          * object database even when it may contain conflicts).
 186          */
 187         if (write_sha1_file(result_buf.ptr, result_buf.size,
 188                             blob_type, sha1))
 189                 die(_("Unable to add merge result for '%s'"), path);
 190         ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
 191                               sha1,
 192                               path, 2, 0);
 193         if (!ce)
 194                 die(_("make_cache_entry failed for path '%s'"), path);
 195         status = checkout_entry(ce, state, NULL);
 196         return status;
 197 }
 198
 199 static int checkout_paths(struct tree *source_tree, const char **pathspec,
 200                           struct checkout_opts *opts)
 201 {
 202         int pos;
 203         struct checkout state;
 204         static char *ps_matched;
 205         unsigned char rev[20];
 206         int flag;
 207         struct commit *head;
 208         int errs = 0;
 209         int stage = opts->writeout_stage;
 210         int merge = opts->merge;
 211         int newfd;
 212         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 213
 214         newfd = hold_locked_index(lock_file, 1);
 215         if (read_cache_preload(pathspec) < 0)
 216                 return error(_("corrupt index file"));
 217
 218         if (source_tree)
 219                 read_tree_some(source_tree, pathspec);
 220
 221         for (pos = 0; pathspec[pos]; pos++)
 222                 ;
 223         ps_matched = xcalloc(1, pos);
 224
 225         for (pos = 0; pos < active_nr; pos++) {
 226                 struct cache_entry *ce = active_cache[pos];
 227                 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
 228         }
 229
 230         if (report_path_error(ps_matched, pathspec, 0))
 231                 return 1;
 232
 233         /* "checkout -m path" to recreate conflicted state */
 234         if (opts->merge)
 235                 unmerge_cache(pathspec);
 236
 237         /* Any unmerged paths? */
 238         for (pos = 0; pos < active_nr; pos++) {
 239                 struct cache_entry *ce = active_cache[pos];
 240                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 241                         if (!ce_stage(ce))
 242                                 continue;
 243                         if (opts->force) {
 244                                 warning(_("path '%s' is unmerged"), ce->name);
 245                         } else if (stage) {
 246                                 errs |= check_stage(stage, ce, pos);
 247                         } else if (opts->merge) {
 248                                 errs |= check_all_stages(ce, pos);
 249                         } else {
 250                                 errs = 1;
 251                                 error(_("path '%s' is unmerged"), ce->name);
 252                         }
 253                         pos = skip_same_name(ce, pos) - 1;
 254                 }
 255         }
 256         if (errs)
 257                 return 1;
 258
 259         /* Now we are committed to check them out */
 260         memset(&state, 0, sizeof(state));
 261         state.force = 1;
 262         state.refresh_cache = 1;
 263         for (pos = 0; pos < active_nr; pos++) {
 264                 struct cache_entry *ce = active_cache[pos];
 265                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 266                         if (!ce_stage(ce)) {
 267                                 errs |= checkout_entry(ce, &state, NULL);
 268                                 continue;
 269                         }
 270                         if (stage)
 271                                 errs |= checkout_stage(stage, ce, pos, &state);
 272                         else if (merge)
 273                                 errs |= checkout_merged(pos, &state);
 274                         pos = skip_same_name(ce, pos) - 1;
 275                 }
 276         }
 277
 278         if (write_cache(newfd, active_cache, active_nr) ||
 279             commit_locked_index(lock_file))
 280                 die(_("unable to write new index file"));
 281
 282         resolve_ref("HEAD", rev, 0, &flag);
 283         head = lookup_commit_reference_gently(rev, 1);
 284
 285         errs |= post_checkout_hook(head, head, 0);
 286         return errs;
 287 }
 288
 289 static void show_local_changes(struct object *head, struct diff_options *opts)
 290 {
 291         struct rev_info rev;
 292         /* I think we want full paths, even if we're in a subdirectory. */
 293         init_revisions(&rev, NULL);
 294         rev.diffopt.flags = opts->flags;
 295         rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 296         if (diff_setup_done(&rev.diffopt) < 0)
 297                 die(_("diff_setup_done failed"));
 298         add_pending_object(&rev, head, NULL);
 299         run_diff_index(&rev, 0);
 300 }
 301
 302 static void describe_detached_head(const char *msg, struct commit *commit)
 303 {
 304         struct strbuf sb = STRBUF_INIT;
 305         struct pretty_print_context ctx = {0};
 306         parse_commit(commit);
 307         pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
 308         fprintf(stderr, "%s %s... %s\n", msg,
 309                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
 310         strbuf_release(&sb);
 311 }
 312
 313 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
 314 {
 315         struct unpack_trees_options opts;
 316         struct tree_desc tree_desc;
 317
 318         memset(&opts, 0, sizeof(opts));
 319         opts.head_idx = -1;
 320         opts.update = worktree;
 321         opts.skip_unmerged = !worktree;
 322         opts.reset = 1;
 323         opts.merge = 1;
 324         opts.fn = oneway_merge;
 325         opts.verbose_update = !o->quiet;
 326         opts.src_index = &the_index;
 327         opts.dst_index = &the_index;
 328         parse_tree(tree);
 329         init_tree_desc(&tree_desc, tree->buffer, tree->size);
 330         switch (unpack_trees(1, &tree_desc, &opts)) {
 331         case -2:
 332                 o->writeout_error = 1;
 333                 /*
 334                  * We return 0 nevertheless, as the index is all right
 335                  * and more importantly we have made best efforts to
 336                  * update paths in the work tree, and we cannot revert
 337                  * them.
 338                  */
 339         case 0:
 340                 return 0;
 341         default:
 342                 return 128;
 343         }
 344 }
 345
 346 struct branch_info {
 347         const char *name; /* The short name used */
 348         const char *path; /* The full name of a real branch */
 349         struct commit *commit; /* The named commit */
 350 };
 351
 352 static void setup_branch_path(struct branch_info *branch)
 353 {
 354         struct strbuf buf = STRBUF_INIT;
 355
 356         strbuf_branchname(&buf, branch->name);
 357         if (strcmp(buf.buf, branch->name))
 358                 branch->name = xstrdup(buf.buf);
 359         strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 360         branch->path = strbuf_detach(&buf, NULL);
 361 }
 362
 363 static int merge_working_tree(struct checkout_opts *opts,
 364                               struct branch_info *old, struct branch_info *new)
 365 {
 366         int ret;
 367         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 368         int newfd = hold_locked_index(lock_file, 1);
 369
 370         if (read_cache_preload(NULL) < 0)
 371                 return error(_("corrupt index file"));
 372
 373         resolve_undo_clear();
 374         if (opts->force) {
 375                 ret = reset_tree(new->commit->tree, opts, 1);
 376                 if (ret)
 377                         return ret;
 378         } else {
 379                 struct tree_desc trees[2];
 380                 struct tree *tree;
 381                 struct unpack_trees_options topts;
 382
 383                 memset(&topts, 0, sizeof(topts));
 384                 topts.head_idx = -1;
 385                 topts.src_index = &the_index;
 386                 topts.dst_index = &the_index;
 387
 388                 setup_unpack_trees_porcelain(&topts, "checkout");
 389
 390                 refresh_cache(REFRESH_QUIET);
 391
 392                 if (unmerged_cache()) {
 393                         error(_("you need to resolve your current index first"));
 394                         return 1;
 395                 }
 396
 397                 /* 2-way merge to the new branch */
 398                 topts.initial_checkout = is_cache_unborn();
 399                 topts.update = 1;
 400                 topts.merge = 1;
 401                 topts.gently = opts->merge && old->commit;
 402                 topts.verbose_update = !opts->quiet;
 403                 topts.fn = twoway_merge;
 404                 topts.dir = xcalloc(1, sizeof(*topts.dir));
 405                 topts.dir->flags |= DIR_SHOW_IGNORED;
 406                 topts.dir->exclude_per_dir = ".gitignore";
 407                 tree = parse_tree_indirect(old->commit ?
 408                                            old->commit->object.sha1 :
 409                                            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                                 if (opts->branch_exists)
 554                                         fprintf(stderr, _("Switched to and reset branch '%s'\n"), new->name);
 555                                 else
 556                                         fprintf(stderr, _("Switched to a new branch '%s'\n"), new->name);
 557                         } else {
 558                                 fprintf(stderr, _("Switched to branch '%s'\n"),
 559                                         new->name);
 560                         }
 561                 }
 562                 if (old->path && old->name) {
 563                         char log_file[PATH_MAX], ref_file[PATH_MAX];
 564
 565                         git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 566                         git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 567                         if (!file_exists(ref_file) && file_exists(log_file))
 568                                 remove_path(log_file);
 569                 }
 570         } else if (strcmp(new->name, "HEAD")) {
 571                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 572                            REF_NODEREF, DIE_ON_ERR);
 573                 if (!opts->quiet) {
 574                         if (old->path && advice_detached_head)
 575                                 detach_advice(old->path, new->name);
 576                         describe_detached_head(_("HEAD is now at"), new->commit);
 577                 }
 578         }
 579         remove_branch_state();
 580         strbuf_release(&msg);
 581         if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 582                 report_tracking(new);
 583 }
 584
 585 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 586 {
 587         int ret = 0;
 588         struct branch_info old;
 589         unsigned char rev[20];
 590         int flag;
 591         memset(&old, 0, sizeof(old));
 592         old.path = resolve_ref("HEAD", rev, 0, &flag);
 593         old.commit = lookup_commit_reference_gently(rev, 1);
 594         if (!(flag & REF_ISSYMREF))
 595                 old.path = NULL;
 596
 597         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 598                 old.name = old.path + strlen("refs/heads/");
 599
 600         if (!new->name) {
 601                 new->name = "HEAD";
 602                 new->commit = old.commit;
 603                 if (!new->commit)
 604                         die(_("You are on a branch yet to be born"));
 605                 parse_commit(new->commit);
 606         }
 607
 608         ret = merge_working_tree(opts, &old, new);
 609         if (ret)
 610                 return ret;
 611
 612         /*
 613          * If we were on a detached HEAD, but have now moved to
 614          * a new commit, we want to mention the old commit once more
 615          * to remind the user that it might be lost.
 616          */
 617         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 618                 describe_detached_head(_("Previous HEAD position was"), old.commit);
 619
 620         update_refs_for_switch(opts, &old, new);
 621
 622         ret = post_checkout_hook(old.commit, new->commit, 1);
 623         return ret || opts->writeout_error;
 624 }
 625
 626 static int git_checkout_config(const char *var, const char *value, void *cb)
 627 {
 628         if (!strcmp(var, "diff.ignoresubmodules")) {
 629                 struct checkout_opts *opts = cb;
 630                 handle_ignore_submodules_arg(&opts->diff_options, value);
 631                 return 0;
 632         }
 633
 634         if (!prefixcmp(var, "submodule."))
 635                 return parse_submodule_config_option(var, value);
 636
 637         return git_xmerge_config(var, value, NULL);
 638 }
 639
 640 static int interactive_checkout(const char *revision, const char **pathspec,
 641                                 struct checkout_opts *opts)
 642 {
 643         return run_add_interactive(revision, "--patch=checkout", pathspec);
 644 }
 645
 646 struct tracking_name_data {
 647         const char *name;
 648         char *remote;
 649         int unique;
 650 };
 651
 652 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 653                                int flags, void *cb_data)
 654 {
 655         struct tracking_name_data *cb = cb_data;
 656         const char *slash;
 657
 658         if (prefixcmp(refname, "refs/remotes/"))
 659                 return 0;
 660         slash = strchr(refname + 13, '/');
 661         if (!slash || strcmp(slash + 1, cb->name))
 662                 return 0;
 663         if (cb->remote) {
 664                 cb->unique = 0;
 665                 return 0;
 666         }
 667         cb->remote = xstrdup(refname);
 668         return 0;
 669 }
 670
 671 static const char *unique_tracking_name(const char *name)
 672 {
 673         struct tracking_name_data cb_data = { NULL, NULL, 1 };
 674         cb_data.name = name;
 675         for_each_ref(check_tracking_name, &cb_data);
 676         if (cb_data.unique)
 677                 return cb_data.remote;
 678         free(cb_data.remote);
 679         return NULL;
 680 }
 681
 682 int cmd_checkout(int argc, const char **argv, const char *prefix)
 683 {
 684         struct checkout_opts opts;
 685         unsigned char rev[20];
 686         const char *arg;
 687         struct branch_info new;
 688         struct tree *source_tree = NULL;
 689         char *conflict_style = NULL;
 690         int patch_mode = 0;
 691         int dwim_new_local_branch = 1;
 692         struct option options[] = {
 693                 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
 694                 OPT_STRING('b', NULL, &opts.new_branch, "branch",
 695                            "create and checkout a new branch"),
 696                 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 697                            "create/reset and checkout a branch"),
 698                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
 699                 OPT_SET_INT('t', "track",  &opts.track, "set upstream info for new branch",
 700                         BRANCH_TRACK_EXPLICIT),
 701                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 702                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
 703                             2),
 704                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
 705                             3),
 706                 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
 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                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 840                         setup_branch_path(&new);
 841
 842                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 843                             resolve_ref(new.path, rev, 1, NULL))
 844                                 ;
 845                         else
 846                                 new.path = NULL;
 847                         parse_commit(new.commit);
 848                         source_tree = new.commit->tree;
 849                 } else
 850                         source_tree = parse_tree_indirect(rev);
 851
 852                 if (!source_tree)                   /* case (1): want a tree */
 853                         die(_("reference is not a tree: %s"), arg);
 854                 if (!has_dash_dash) {/* case (3 -> 1) */
 855                         /*
 856                          * Do not complain the most common case
 857                          *      git checkout branch
 858                          * even if there happen to be a file called 'branch';
 859                          * it would be extremely annoying.
 860                          */
 861                         if (argc)
 862                                 verify_non_filename(NULL, arg);
 863                 }
 864                 else {
 865                         argv++;
 866                         argc--;
 867                 }
 868         }
 869
 870 no_reference:
 871
 872         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 873                 opts.track = git_branch_track;
 874
 875         if (argc) {
 876                 const char **pathspec = get_pathspec(prefix, argv);
 877
 878                 if (!pathspec)
 879                         die(_("invalid path specification"));
 880
 881                 if (patch_mode)
 882                         return interactive_checkout(new.name, pathspec, &opts);
 883
 884                 /* Checkout paths */
 885                 if (opts.new_branch) {
 886                         if (argc == 1) {
 887                                 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]);
 888                         } else {
 889                                 die(_("git checkout: updating paths is incompatible with switching branches."));
 890                         }
 891                 }
 892
 893                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 894                         die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
 895
 896                 return checkout_paths(source_tree, pathspec, &opts);
 897         }
 898
 899         if (patch_mode)
 900                 return interactive_checkout(new.name, NULL, &opts);
 901
 902         if (opts.new_branch) {
 903                 struct strbuf buf = STRBUF_INIT;
 904                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 905                         die(_("git checkout: we do not like '%s' as a branch name."),
 906                             opts.new_branch);
 907                 if (!get_sha1(buf.buf, rev)) {
 908                         opts.branch_exists = 1;
 909                         if (!opts.new_branch_force)
 910                                 die(_("git checkout: branch %s already exists"),
 911                                     opts.new_branch);
 912                 }
 913                 strbuf_release(&buf);
 914         }
 915
 916         if (new.name && !new.commit) {
 917                 die(_("Cannot switch branch to a non-commit."));
 918         }
 919         if (opts.writeout_stage)
 920                 die(_("--ours/--theirs is incompatible with switching branches."));
 921
 922         return switch_branches(&opts, &new);
 923 }