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