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