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