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