builtin/checkout.c

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