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, "base",
 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.ancestor = old->name;
 443                         o.branch1 = new->name;
 444                         o.branch2 = "local";
 445                         merge_trees(&o, new->commit->tree, work,
 446                                 old->commit->tree, &result);
 447                         ret = reset_tree(new->commit->tree, opts, 0);
 448                         if (ret)
 449                                 return ret;
 450                 }
 451         }
 452
 453         if (write_cache(newfd, active_cache, active_nr) ||
 454             commit_locked_index(lock_file))
 455                 die("unable to write new index file");
 456
 457         if (!opts->force && !opts->quiet)
 458                 show_local_changes(&new->commit->object);
 459
 460         return 0;
 461 }
 462
 463 static void report_tracking(struct branch_info *new)
 464 {
 465         struct strbuf sb = STRBUF_INIT;
 466         struct branch *branch = branch_get(new->name);
 467
 468         if (!format_tracking_info(branch, &sb))
 469                 return;
 470         fputs(sb.buf, stdout);
 471         strbuf_release(&sb);
 472 }
 473
 474 static void detach_advice(const char *old_path, const char *new_name)
 475 {
 476         const char fmt[] =
 477         "Note: checking out '%s'.\n\n"
 478         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 479         "changes and commit them, and you can discard any commits you make in this\n"
 480         "state without impacting any branches by performing another checkout.\n\n"
 481         "If you want to create a new branch to retain commits you create, you may\n"
 482         "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 483         "  git checkout -b new_branch_name\n\n";
 484
 485         fprintf(stderr, fmt, new_name);
 486 }
 487
 488 static void update_refs_for_switch(struct checkout_opts *opts,
 489                                    struct branch_info *old,
 490                                    struct branch_info *new)
 491 {
 492         struct strbuf msg = STRBUF_INIT;
 493         const char *old_desc;
 494         if (opts->new_branch) {
 495                 create_branch(old->name, opts->new_branch, new->name, 0,
 496                               opts->new_branch_log, opts->track);
 497                 new->name = opts->new_branch;
 498                 setup_branch_path(new);
 499         }
 500
 501         old_desc = old->name;
 502         if (!old_desc && old->commit)
 503                 old_desc = sha1_to_hex(old->commit->object.sha1);
 504         strbuf_addf(&msg, "checkout: moving from %s to %s",
 505                     old_desc ? old_desc : "(invalid)", new->name);
 506
 507         if (new->path) {
 508                 create_symref("HEAD", new->path, msg.buf);
 509                 if (!opts->quiet) {
 510                         if (old->path && !strcmp(new->path, old->path))
 511                                 fprintf(stderr, "Already on '%s'\n",
 512                                         new->name);
 513                         else
 514                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 515                                         opts->new_branch ? " a new" : "",
 516                                         new->name);
 517                 }
 518         } else if (strcmp(new->name, "HEAD")) {
 519                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 520                            REF_NODEREF, DIE_ON_ERR);
 521                 if (!opts->quiet) {
 522                         if (old->path && advice_detached_head)
 523                                 detach_advice(old->path, new->name);
 524                         describe_detached_head("HEAD is now at", new->commit);
 525                 }
 526         }
 527         remove_branch_state();
 528         strbuf_release(&msg);
 529         if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 530                 report_tracking(new);
 531 }
 532
 533 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 534 {
 535         int ret = 0;
 536         struct branch_info old;
 537         unsigned char rev[20];
 538         int flag;
 539         memset(&old, 0, sizeof(old));
 540         old.path = resolve_ref("HEAD", rev, 0, &flag);
 541         old.commit = lookup_commit_reference_gently(rev, 1);
 542         if (!(flag & REF_ISSYMREF))
 543                 old.path = NULL;
 544
 545         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 546                 old.name = old.path + strlen("refs/heads/");
 547
 548         if (!new->name) {
 549                 new->name = "HEAD";
 550                 new->commit = old.commit;
 551                 if (!new->commit)
 552                         die("You are on a branch yet to be born");
 553                 parse_commit(new->commit);
 554         }
 555
 556         ret = merge_working_tree(opts, &old, new);
 557         if (ret)
 558                 return ret;
 559
 560         /*
 561          * If we were on a detached HEAD, but have now moved to
 562          * a new commit, we want to mention the old commit once more
 563          * to remind the user that it might be lost.
 564          */
 565         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 566                 describe_detached_head("Previous HEAD position was", old.commit);
 567
 568         update_refs_for_switch(opts, &old, new);
 569
 570         ret = post_checkout_hook(old.commit, new->commit, 1);
 571         return ret || opts->writeout_error;
 572 }
 573
 574 static int git_checkout_config(const char *var, const char *value, void *cb)
 575 {
 576         return git_xmerge_config(var, value, cb);
 577 }
 578
 579 static int interactive_checkout(const char *revision, const char **pathspec,
 580                                 struct checkout_opts *opts)
 581 {
 582         return run_add_interactive(revision, "--patch=checkout", pathspec);
 583 }
 584
 585 struct tracking_name_data {
 586         const char *name;
 587         char *remote;
 588         int unique;
 589 };
 590
 591 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 592                                int flags, void *cb_data)
 593 {
 594         struct tracking_name_data *cb = cb_data;
 595         const char *slash;
 596
 597         if (prefixcmp(refname, "refs/remotes/"))
 598                 return 0;
 599         slash = strchr(refname + 13, '/');
 600         if (!slash || strcmp(slash + 1, cb->name))
 601                 return 0;
 602         if (cb->remote) {
 603                 cb->unique = 0;
 604                 return 0;
 605         }
 606         cb->remote = xstrdup(refname);
 607         return 0;
 608 }
 609
 610 static const char *unique_tracking_name(const char *name)
 611 {
 612         struct tracking_name_data cb_data = { name, NULL, 1 };
 613         for_each_ref(check_tracking_name, &cb_data);
 614         if (cb_data.unique)
 615                 return cb_data.remote;
 616         free(cb_data.remote);
 617         return NULL;
 618 }
 619
 620 int cmd_checkout(int argc, const char **argv, const char *prefix)
 621 {
 622         struct checkout_opts opts;
 623         unsigned char rev[20];
 624         const char *arg;
 625         struct branch_info new;
 626         struct tree *source_tree = NULL;
 627         char *conflict_style = NULL;
 628         int patch_mode = 0;
 629         int dwim_new_local_branch = 1;
 630         struct option options[] = {
 631                 OPT__QUIET(&opts.quiet),
 632                 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
 633                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 634                 OPT_SET_INT('t', "track",  &opts.track, "track",
 635                         BRANCH_TRACK_EXPLICIT),
 636                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 637                             2),
 638                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 639                             3),
 640                 OPT_BOOLEAN('f', "force", &opts.force, "force"),
 641                 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 642                 OPT_STRING(0, "conflict", &conflict_style, "style",
 643                            "conflict style (merge or diff3)"),
 644                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 645                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 646                   "second guess 'git checkout no-such-branch'",
 647                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 648                 OPT_END(),
 649         };
 650         int has_dash_dash;
 651
 652         memset(&opts, 0, sizeof(opts));
 653         memset(&new, 0, sizeof(new));
 654
 655         git_config(git_checkout_config, NULL);
 656
 657         opts.track = BRANCH_TRACK_UNSPECIFIED;
 658
 659         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 660                              PARSE_OPT_KEEP_DASHDASH);
 661
 662         if (patch_mode && (opts.track > 0 || opts.new_branch
 663                            || opts.new_branch_log || opts.merge || opts.force))
 664                 die ("--patch is incompatible with all other options");
 665
 666         /* --track without -b should DWIM */
 667         if (0 < opts.track && !opts.new_branch) {
 668                 const char *argv0 = argv[0];
 669                 if (!argc || !strcmp(argv0, "--"))
 670                         die ("--track needs a branch name");
 671                 if (!prefixcmp(argv0, "refs/"))
 672                         argv0 += 5;
 673                 if (!prefixcmp(argv0, "remotes/"))
 674                         argv0 += 8;
 675                 argv0 = strchr(argv0, '/');
 676                 if (!argv0 || !argv0[1])
 677                         die ("Missing branch name; try -b");
 678                 opts.new_branch = argv0 + 1;
 679         }
 680
 681         if (conflict_style) {
 682                 opts.merge = 1; /* implied */
 683                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 684         }
 685
 686         if (opts.force && opts.merge)
 687                 die("git checkout: -f and -m are incompatible");
 688
 689         /*
 690          * case 1: git checkout <ref> -- [<paths>]
 691          *
 692          *   <ref> must be a valid tree, everything after the '--' must be
 693          *   a path.
 694          *
 695          * case 2: git checkout -- [<paths>]
 696          *
 697          *   everything after the '--' must be paths.
 698          *
 699          * case 3: git checkout <something> [<paths>]
 700          *
 701          *   With no paths, if <something> is a commit, that is to
 702          *   switch to the branch or detach HEAD at it.  As a special case,
 703          *   if <something> is A...B (missing A or B means HEAD but you can
 704          *   omit at most one side), and if there is a unique merge base
 705          *   between A and B, A...B names that merge base.
 706          *
 707          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 708          *   was given, and there is a tracking branch whose name is
 709          *   <something> in one and only one remote, then this is a short-hand
 710          *   to fork local <something> from that remote tracking branch.
 711          *
 712          *   Otherwise <something> shall not be ambiguous.
 713          *   - If it's *only* a reference, treat it like case (1).
 714          *   - If it's only a path, treat it like case (2).
 715          *   - else: fail.
 716          *
 717          */
 718         if (argc) {
 719                 if (!strcmp(argv[0], "--")) {       /* case (2) */
 720                         argv++;
 721                         argc--;
 722                         goto no_reference;
 723                 }
 724
 725                 arg = argv[0];
 726                 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 727
 728                 if (!strcmp(arg, "-"))
 729                         arg = "@{-1}";
 730
 731                 if (get_sha1_mb(arg, rev)) {
 732                         if (has_dash_dash)          /* case (1) */
 733                                 die("invalid reference: %s", arg);
 734                         if (!patch_mode &&
 735                             dwim_new_local_branch &&
 736                             opts.track == BRANCH_TRACK_UNSPECIFIED &&
 737                             !opts.new_branch &&
 738                             !check_filename(NULL, arg) &&
 739                             argc == 1) {
 740                                 const char *remote = unique_tracking_name(arg);
 741                                 if (!remote || get_sha1(remote, rev))
 742                                         goto no_reference;
 743                                 opts.new_branch = arg;
 744                                 arg = remote;
 745                                 /* DWIMmed to create local branch */
 746                         }
 747                         else
 748                                 goto no_reference;
 749                 }
 750
 751                 /* we can't end up being in (2) anymore, eat the argument */
 752                 argv++;
 753                 argc--;
 754
 755                 new.name = arg;
 756                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 757                         setup_branch_path(&new);
 758
 759                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 760                             resolve_ref(new.path, rev, 1, NULL))
 761                                 ;
 762                         else
 763                                 new.path = NULL;
 764                         parse_commit(new.commit);
 765                         source_tree = new.commit->tree;
 766                 } else
 767                         source_tree = parse_tree_indirect(rev);
 768
 769                 if (!source_tree)                   /* case (1): want a tree */
 770                         die("reference is not a tree: %s", arg);
 771                 if (!has_dash_dash) {/* case (3 -> 1) */
 772                         /*
 773                          * Do not complain the most common case
 774                          *      git checkout branch
 775                          * even if there happen to be a file called 'branch';
 776                          * it would be extremely annoying.
 777                          */
 778                         if (argc)
 779                                 verify_non_filename(NULL, arg);
 780                 }
 781                 else {
 782                         argv++;
 783                         argc--;
 784                 }
 785         }
 786
 787 no_reference:
 788
 789         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 790                 opts.track = git_branch_track;
 791
 792         if (argc) {
 793                 const char **pathspec = get_pathspec(prefix, argv);
 794
 795                 if (!pathspec)
 796                         die("invalid path specification");
 797
 798                 if (patch_mode)
 799                         return interactive_checkout(new.name, pathspec, &opts);
 800
 801                 /* Checkout paths */
 802                 if (opts.new_branch) {
 803                         if (argc == 1) {
 804                                 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]);
 805                         } else {
 806                                 die("git checkout: updating paths is incompatible with switching branches.");
 807                         }
 808                 }
 809
 810                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 811                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 812
 813                 return checkout_paths(source_tree, pathspec, &opts);
 814         }
 815
 816         if (patch_mode)
 817                 return interactive_checkout(new.name, NULL, &opts);
 818
 819         if (opts.new_branch) {
 820                 struct strbuf buf = STRBUF_INIT;
 821                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 822                         die("git checkout: we do not like '%s' as a branch name.",
 823                             opts.new_branch);
 824                 if (!get_sha1(buf.buf, rev))
 825                         die("git checkout: branch %s already exists", opts.new_branch);
 826                 strbuf_release(&buf);
 827         }
 828
 829         if (new.name && !new.commit) {
 830                 die("Cannot switch branch to a non-commit.");
 831         }
 832         if (opts.writeout_stage)
 833                 die("--ours/--theirs is incompatible with switching branches.");
 834
 835         return switch_branches(&opts, &new);
 836 }