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