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) | CE_UPDATE;
  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                 if (source_tree && !(ce->ce_flags & CE_UPDATE))
 226                         continue;
 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 (source_tree && !(ce->ce_flags & CE_UPDATE))
 266                         continue;
 267                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 268                         if (!ce_stage(ce)) {
 269                                 errs |= checkout_entry(ce, &state, NULL);
 270                                 continue;
 271                         }
 272                         if (stage)
 273                                 errs |= checkout_stage(stage, ce, pos, &state);
 274                         else if (merge)
 275                                 errs |= checkout_merged(pos, &state);
 276                         pos = skip_same_name(ce, pos) - 1;
 277                 }
 278         }
 279
 280         if (write_cache(newfd, active_cache, active_nr) ||
 281             commit_locked_index(lock_file))
 282                 die("unable to write new index file");
 283
 284         resolve_ref("HEAD", rev, 0, &flag);
 285         head = lookup_commit_reference_gently(rev, 1);
 286
 287         errs |= post_checkout_hook(head, head, 0);
 288         return errs;
 289 }
 290
 291 static void show_local_changes(struct object *head, struct diff_options *opts)
 292 {
 293         struct rev_info rev;
 294         /* I think we want full paths, even if we're in a subdirectory. */
 295         init_revisions(&rev, NULL);
 296         rev.diffopt.flags = opts->flags;
 297         rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 298         if (diff_setup_done(&rev.diffopt) < 0)
 299                 die("diff_setup_done failed");
 300         add_pending_object(&rev, head, NULL);
 301         run_diff_index(&rev, 0);
 302 }
 303
 304 static void describe_detached_head(char *msg, struct commit *commit)
 305 {
 306         struct strbuf sb = STRBUF_INIT;
 307         struct pretty_print_context ctx = {0};
 308         parse_commit(commit);
 309         pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
 310         fprintf(stderr, "%s %s... %s\n", msg,
 311                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
 312         strbuf_release(&sb);
 313 }
 314
 315 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
 316 {
 317         struct unpack_trees_options opts;
 318         struct tree_desc tree_desc;
 319
 320         memset(&opts, 0, sizeof(opts));
 321         opts.head_idx = -1;
 322         opts.update = worktree;
 323         opts.skip_unmerged = !worktree;
 324         opts.reset = 1;
 325         opts.merge = 1;
 326         opts.fn = oneway_merge;
 327         opts.verbose_update = !o->quiet;
 328         opts.src_index = &the_index;
 329         opts.dst_index = &the_index;
 330         parse_tree(tree);
 331         init_tree_desc(&tree_desc, tree->buffer, tree->size);
 332         switch (unpack_trees(1, &tree_desc, &opts)) {
 333         case -2:
 334                 o->writeout_error = 1;
 335                 /*
 336                  * We return 0 nevertheless, as the index is all right
 337                  * and more importantly we have made best efforts to
 338                  * update paths in the work tree, and we cannot revert
 339                  * them.
 340                  */
 341         case 0:
 342                 return 0;
 343         default:
 344                 return 128;
 345         }
 346 }
 347
 348 struct branch_info {
 349         const char *name; /* The short name used */
 350         const char *path; /* The full name of a real branch */
 351         struct commit *commit; /* The named commit */
 352 };
 353
 354 static void setup_branch_path(struct branch_info *branch)
 355 {
 356         struct strbuf buf = STRBUF_INIT;
 357
 358         strbuf_branchname(&buf, branch->name);
 359         if (strcmp(buf.buf, branch->name))
 360                 branch->name = xstrdup(buf.buf);
 361         strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 362         branch->path = strbuf_detach(&buf, NULL);
 363 }
 364
 365 static int merge_working_tree(struct checkout_opts *opts,
 366                               struct branch_info *old, struct branch_info *new)
 367 {
 368         int ret;
 369         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 370         int newfd = hold_locked_index(lock_file, 1);
 371
 372         if (read_cache_preload(NULL) < 0)
 373                 return error("corrupt index file");
 374
 375         resolve_undo_clear();
 376         if (opts->force) {
 377                 ret = reset_tree(new->commit->tree, opts, 1);
 378                 if (ret)
 379                         return ret;
 380         } else {
 381                 struct tree_desc trees[2];
 382                 struct tree *tree;
 383                 struct unpack_trees_options topts;
 384
 385                 memset(&topts, 0, sizeof(topts));
 386                 topts.head_idx = -1;
 387                 topts.src_index = &the_index;
 388                 topts.dst_index = &the_index;
 389
 390                 setup_unpack_trees_porcelain(&topts, "checkout");
 391
 392                 refresh_cache(REFRESH_QUIET);
 393
 394                 if (unmerged_cache()) {
 395                         error("you need to resolve your current index first");
 396                         return 1;
 397                 }
 398
 399                 /* 2-way merge to the new branch */
 400                 topts.initial_checkout = is_cache_unborn();
 401                 topts.update = 1;
 402                 topts.merge = 1;
 403                 topts.gently = opts->merge && old->commit;
 404                 topts.verbose_update = !opts->quiet;
 405                 topts.fn = twoway_merge;
 406                 topts.dir = xcalloc(1, sizeof(*topts.dir));
 407                 topts.dir->flags |= DIR_SHOW_IGNORED;
 408                 topts.dir->exclude_per_dir = ".gitignore";
 409                 tree = parse_tree_indirect(old->commit ?
 410                                            old->commit->object.sha1 :
 411                                            (unsigned char *)EMPTY_TREE_SHA1_BIN);
 412                 init_tree_desc(&trees[0], tree->buffer, tree->size);
 413                 tree = parse_tree_indirect(new->commit->object.sha1);
 414                 init_tree_desc(&trees[1], tree->buffer, tree->size);
 415
 416                 ret = unpack_trees(2, trees, &topts);
 417                 if (ret == -1) {
 418                         /*
 419                          * Unpack couldn't do a trivial merge; either
 420                          * give up or do a real merge, depending on
 421                          * whether the merge flag was used.
 422                          */
 423                         struct tree *result;
 424                         struct tree *work;
 425                         struct merge_options o;
 426                         if (!opts->merge)
 427                                 return 1;
 428
 429                         /*
 430                          * Without old->commit, the below is the same as
 431                          * the two-tree unpack we already tried and failed.
 432                          */
 433                         if (!old->commit)
 434                                 return 1;
 435
 436                         /* Do more real merge */
 437
 438                         /*
 439                          * We update the index fully, then write the
 440                          * tree from the index, then merge the new
 441                          * branch with the current tree, with the old
 442                          * branch as the base. Then we reset the index
 443                          * (but not the working tree) to the new
 444                          * branch, leaving the working tree as the
 445                          * merged version, but skipping unmerged
 446                          * entries in the index.
 447                          */
 448
 449                         add_files_to_cache(NULL, NULL, 0);
 450                         /*
 451                          * NEEDSWORK: carrying over local changes
 452                          * when branches have different end-of-line
 453                          * normalization (or clean+smudge rules) is
 454                          * a pain; plumb in an option to set
 455                          * o.renormalize?
 456                          */
 457                         init_merge_options(&o);
 458                         o.verbosity = 0;
 459                         work = write_tree_from_memory(&o);
 460
 461                         ret = reset_tree(new->commit->tree, opts, 1);
 462                         if (ret)
 463                                 return ret;
 464                         o.ancestor = old->name;
 465                         o.branch1 = new->name;
 466                         o.branch2 = "local";
 467                         merge_trees(&o, new->commit->tree, work,
 468                                 old->commit->tree, &result);
 469                         ret = reset_tree(new->commit->tree, opts, 0);
 470                         if (ret)
 471                                 return ret;
 472                 }
 473         }
 474
 475         if (write_cache(newfd, active_cache, active_nr) ||
 476             commit_locked_index(lock_file))
 477                 die("unable to write new index file");
 478
 479         if (!opts->force && !opts->quiet)
 480                 show_local_changes(&new->commit->object, &opts->diff_options);
 481
 482         return 0;
 483 }
 484
 485 static void report_tracking(struct branch_info *new)
 486 {
 487         struct strbuf sb = STRBUF_INIT;
 488         struct branch *branch = branch_get(new->name);
 489
 490         if (!format_tracking_info(branch, &sb))
 491                 return;
 492         fputs(sb.buf, stdout);
 493         strbuf_release(&sb);
 494 }
 495
 496 static void detach_advice(const char *old_path, const char *new_name)
 497 {
 498         const char fmt[] =
 499         "Note: checking out '%s'.\n\n"
 500         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 501         "changes and commit them, and you can discard any commits you make in this\n"
 502         "state without impacting any branches by performing another checkout.\n\n"
 503         "If you want to create a new branch to retain commits you create, you may\n"
 504         "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 505         "  git checkout -b new_branch_name\n\n";
 506
 507         fprintf(stderr, fmt, new_name);
 508 }
 509
 510 static void update_refs_for_switch(struct checkout_opts *opts,
 511                                    struct branch_info *old,
 512                                    struct branch_info *new)
 513 {
 514         struct strbuf msg = STRBUF_INIT;
 515         const char *old_desc;
 516         if (opts->new_branch) {
 517                 if (opts->new_orphan_branch) {
 518                         if (opts->new_branch_log && !log_all_ref_updates) {
 519                                 int temp;
 520                                 char log_file[PATH_MAX];
 521                                 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
 522
 523                                 temp = log_all_ref_updates;
 524                                 log_all_ref_updates = 1;
 525                                 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
 526                                         fprintf(stderr, "Can not do reflog for '%s'\n",
 527                                             opts->new_orphan_branch);
 528                                         log_all_ref_updates = temp;
 529                                         return;
 530                                 }
 531                                 log_all_ref_updates = temp;
 532                         }
 533                 }
 534                 else
 535                         create_branch(old->name, opts->new_branch, new->name,
 536                                       opts->new_branch_force ? 1 : 0,
 537                                       opts->new_branch_log, opts->track);
 538                 new->name = opts->new_branch;
 539                 setup_branch_path(new);
 540         }
 541
 542         old_desc = old->name;
 543         if (!old_desc && old->commit)
 544                 old_desc = sha1_to_hex(old->commit->object.sha1);
 545         strbuf_addf(&msg, "checkout: moving from %s to %s",
 546                     old_desc ? old_desc : "(invalid)", new->name);
 547
 548         if (new->path) {
 549                 create_symref("HEAD", new->path, msg.buf);
 550                 if (!opts->quiet) {
 551                         if (old->path && !strcmp(new->path, old->path))
 552                                 fprintf(stderr, "Already on '%s'\n",
 553                                         new->name);
 554                         else if (opts->new_branch)
 555                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 556                                         opts->branch_exists ? " and reset" : " a new",
 557                                         new->name);
 558                         else
 559                                 fprintf(stderr, "Switched to branch '%s'\n",
 560                                         new->name);
 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 }