builtin/checkout.c

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