1f7e1546f69acaef5e3c5cca1476acec972cb334
   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
  22static const char * const checkout_usage[] = {
  23        "git checkout [options] <branch>",
  24        "git checkout [options] [<branch>] -- <file>...",
  25        NULL,
  26};
  27
  28struct 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
  45static 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
  57static 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
  77static 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
  88static 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
  96static 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
 109static 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
 122static 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
 136static 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
 191static 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
 281static 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
 293static 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
 304static 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
 337struct 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
 343static 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
 354static int merge_working_tree(struct checkout_opts *opts,
 355                              struct branch_info *old, struct branch_info *new)
 356{
 357        int ret;
 358        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 359        int newfd = hold_locked_index(lock_file, 1);
 360
 361        if (read_cache_preload(NULL) < 0)
 362                return error("corrupt index file");
 363
 364        resolve_undo_clear();
 365        if (opts->force) {
 366                ret = reset_tree(new->commit->tree, opts, 1);
 367                if (ret)
 368                        return ret;
 369        } else {
 370                struct tree_desc trees[2];
 371                struct tree *tree;
 372                struct unpack_trees_options topts;
 373
 374                memset(&topts, 0, sizeof(topts));
 375                topts.head_idx = -1;
 376                topts.src_index = &the_index;
 377                topts.dst_index = &the_index;
 378
 379                topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
 380
 381                refresh_cache(REFRESH_QUIET);
 382
 383                if (unmerged_cache()) {
 384                        error("you need to resolve your current index first");
 385                        return 1;
 386                }
 387
 388                /* 2-way merge to the new branch */
 389                topts.initial_checkout = is_cache_unborn();
 390                topts.update = 1;
 391                topts.merge = 1;
 392                topts.gently = opts->merge && old->commit;
 393                topts.verbose_update = !opts->quiet;
 394                topts.fn = twoway_merge;
 395                topts.dir = xcalloc(1, sizeof(*topts.dir));
 396                topts.dir->flags |= DIR_SHOW_IGNORED;
 397                topts.dir->exclude_per_dir = ".gitignore";
 398                tree = parse_tree_indirect(old->commit ?
 399                                           old->commit->object.sha1 :
 400                                           (unsigned char *)EMPTY_TREE_SHA1_BIN);
 401                init_tree_desc(&trees[0], tree->buffer, tree->size);
 402                tree = parse_tree_indirect(new->commit->object.sha1);
 403                init_tree_desc(&trees[1], tree->buffer, tree->size);
 404
 405                ret = unpack_trees(2, trees, &topts);
 406                if (ret == -1) {
 407                        /*
 408                         * Unpack couldn't do a trivial merge; either
 409                         * give up or do a real merge, depending on
 410                         * whether the merge flag was used.
 411                         */
 412                        struct tree *result;
 413                        struct tree *work;
 414                        struct merge_options o;
 415                        if (!opts->merge)
 416                                return 1;
 417
 418                        /*
 419                         * Without old->commit, the below is the same as
 420                         * the two-tree unpack we already tried and failed.
 421                         */
 422                        if (!old->commit)
 423                                return 1;
 424
 425                        /* Do more real merge */
 426
 427                        /*
 428                         * We update the index fully, then write the
 429                         * tree from the index, then merge the new
 430                         * branch with the current tree, with the old
 431                         * branch as the base. Then we reset the index
 432                         * (but not the working tree) to the new
 433                         * branch, leaving the working tree as the
 434                         * merged version, but skipping unmerged
 435                         * entries in the index.
 436                         */
 437
 438                        add_files_to_cache(NULL, NULL, 0);
 439                        init_merge_options(&o);
 440                        o.verbosity = 0;
 441                        work = write_tree_from_memory(&o);
 442
 443                        ret = reset_tree(new->commit->tree, opts, 1);
 444                        if (ret)
 445                                return ret;
 446                        o.ancestor = old->name;
 447                        o.branch1 = new->name;
 448                        o.branch2 = "local";
 449                        merge_trees(&o, new->commit->tree, work,
 450                                old->commit->tree, &result);
 451                        ret = reset_tree(new->commit->tree, opts, 0);
 452                        if (ret)
 453                                return ret;
 454                }
 455        }
 456
 457        if (write_cache(newfd, active_cache, active_nr) ||
 458            commit_locked_index(lock_file))
 459                die("unable to write new index file");
 460
 461        if (!opts->force && !opts->quiet)
 462                show_local_changes(&new->commit->object);
 463
 464        return 0;
 465}
 466
 467static void report_tracking(struct branch_info *new)
 468{
 469        struct strbuf sb = STRBUF_INIT;
 470        struct branch *branch = branch_get(new->name);
 471
 472        if (!format_tracking_info(branch, &sb))
 473                return;
 474        fputs(sb.buf, stdout);
 475        strbuf_release(&sb);
 476}
 477
 478static void detach_advice(const char *old_path, const char *new_name)
 479{
 480        const char fmt[] =
 481        "Note: checking out '%s'.\n\n"
 482        "You are in 'detached HEAD' state. You can look around, make experimental\n"
 483        "changes and commit them, and you can discard any commits you make in this\n"
 484        "state without impacting any branches by performing another checkout.\n\n"
 485        "If you want to create a new branch to retain commits you create, you may\n"
 486        "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 487        "  git checkout -b new_branch_name\n\n";
 488
 489        fprintf(stderr, fmt, new_name);
 490}
 491
 492static void update_refs_for_switch(struct checkout_opts *opts,
 493                                   struct branch_info *old,
 494                                   struct branch_info *new)
 495{
 496        struct strbuf msg = STRBUF_INIT;
 497        const char *old_desc;
 498        if (opts->new_branch) {
 499                if (opts->new_orphan_branch) {
 500                        if (opts->new_branch_log && !log_all_ref_updates) {
 501                                int temp;
 502                                char log_file[PATH_MAX];
 503                                char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
 504
 505                                temp = log_all_ref_updates;
 506                                log_all_ref_updates = 1;
 507                                if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
 508                                        fprintf(stderr, "Can not do reflog for '%s'\n",
 509                                            opts->new_orphan_branch);
 510                                        log_all_ref_updates = temp;
 511                                        return;
 512                                }
 513                                log_all_ref_updates = temp;
 514                        }
 515                }
 516                else
 517                        create_branch(old->name, opts->new_branch, new->name,
 518                                      opts->new_branch_force ? 1 : 0,
 519                                      opts->new_branch_log, opts->track);
 520                new->name = opts->new_branch;
 521                setup_branch_path(new);
 522        }
 523
 524        old_desc = old->name;
 525        if (!old_desc && old->commit)
 526                old_desc = sha1_to_hex(old->commit->object.sha1);
 527        strbuf_addf(&msg, "checkout: moving from %s to %s",
 528                    old_desc ? old_desc : "(invalid)", new->name);
 529
 530        if (new->path) {
 531                create_symref("HEAD", new->path, msg.buf);
 532                if (!opts->quiet) {
 533                        if (old->path && !strcmp(new->path, old->path))
 534                                fprintf(stderr, "Already on '%s'\n",
 535                                        new->name);
 536                        else
 537                                fprintf(stderr, "Switched to%s branch '%s'\n",
 538                                        opts->branch_exists ? " and reset" : " a new",
 539                                        new->name);
 540                }
 541                if (old->path && old->name) {
 542                        char log_file[PATH_MAX], ref_file[PATH_MAX];
 543
 544                        git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 545                        git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 546                        if (!file_exists(ref_file) && file_exists(log_file))
 547                                remove_path(log_file);
 548                }
 549        } else if (strcmp(new->name, "HEAD")) {
 550                update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 551                           REF_NODEREF, DIE_ON_ERR);
 552                if (!opts->quiet) {
 553                        if (old->path && advice_detached_head)
 554                                detach_advice(old->path, new->name);
 555                        describe_detached_head("HEAD is now at", new->commit);
 556                }
 557        }
 558        remove_branch_state();
 559        strbuf_release(&msg);
 560        if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 561                report_tracking(new);
 562}
 563
 564static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 565{
 566        int ret = 0;
 567        struct branch_info old;
 568        unsigned char rev[20];
 569        int flag;
 570        memset(&old, 0, sizeof(old));
 571        old.path = resolve_ref("HEAD", rev, 0, &flag);
 572        old.commit = lookup_commit_reference_gently(rev, 1);
 573        if (!(flag & REF_ISSYMREF))
 574                old.path = NULL;
 575
 576        if (old.path && !prefixcmp(old.path, "refs/heads/"))
 577                old.name = old.path + strlen("refs/heads/");
 578
 579        if (!new->name) {
 580                new->name = "HEAD";
 581                new->commit = old.commit;
 582                if (!new->commit)
 583                        die("You are on a branch yet to be born");
 584                parse_commit(new->commit);
 585        }
 586
 587        ret = merge_working_tree(opts, &old, new);
 588        if (ret)
 589                return ret;
 590
 591        /*
 592         * If we were on a detached HEAD, but have now moved to
 593         * a new commit, we want to mention the old commit once more
 594         * to remind the user that it might be lost.
 595         */
 596        if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 597                describe_detached_head("Previous HEAD position was", old.commit);
 598
 599        update_refs_for_switch(opts, &old, new);
 600
 601        ret = post_checkout_hook(old.commit, new->commit, 1);
 602        return ret || opts->writeout_error;
 603}
 604
 605static int git_checkout_config(const char *var, const char *value, void *cb)
 606{
 607        return git_xmerge_config(var, value, cb);
 608}
 609
 610static int interactive_checkout(const char *revision, const char **pathspec,
 611                                struct checkout_opts *opts)
 612{
 613        return run_add_interactive(revision, "--patch=checkout", pathspec);
 614}
 615
 616struct tracking_name_data {
 617        const char *name;
 618        char *remote;
 619        int unique;
 620};
 621
 622static int check_tracking_name(const char *refname, const unsigned char *sha1,
 623                               int flags, void *cb_data)
 624{
 625        struct tracking_name_data *cb = cb_data;
 626        const char *slash;
 627
 628        if (prefixcmp(refname, "refs/remotes/"))
 629                return 0;
 630        slash = strchr(refname + 13, '/');
 631        if (!slash || strcmp(slash + 1, cb->name))
 632                return 0;
 633        if (cb->remote) {
 634                cb->unique = 0;
 635                return 0;
 636        }
 637        cb->remote = xstrdup(refname);
 638        return 0;
 639}
 640
 641static const char *unique_tracking_name(const char *name)
 642{
 643        struct tracking_name_data cb_data = { NULL, NULL, 1 };
 644        cb_data.name = name;
 645        for_each_ref(check_tracking_name, &cb_data);
 646        if (cb_data.unique)
 647                return cb_data.remote;
 648        free(cb_data.remote);
 649        return NULL;
 650}
 651
 652int cmd_checkout(int argc, const char **argv, const char *prefix)
 653{
 654        struct checkout_opts opts;
 655        unsigned char rev[20];
 656        const char *arg;
 657        struct branch_info new;
 658        struct tree *source_tree = NULL;
 659        char *conflict_style = NULL;
 660        int patch_mode = 0;
 661        int dwim_new_local_branch = 1;
 662        struct option options[] = {
 663                OPT__QUIET(&opts.quiet),
 664                OPT_STRING('b', NULL, &opts.new_branch, "branch",
 665                           "create and checkout a new branch"),
 666                OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 667                           "create/reset and checkout a branch"),
 668                OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 669                OPT_SET_INT('t', "track",  &opts.track, "track",
 670                        BRANCH_TRACK_EXPLICIT),
 671                OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 672                OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 673                            2),
 674                OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 675                            3),
 676                OPT_BOOLEAN('f', "force", &opts.force, "force"),
 677                OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 678                OPT_STRING(0, "conflict", &conflict_style, "style",
 679                           "conflict style (merge or diff3)"),
 680                OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 681                { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 682                  "second guess 'git checkout no-such-branch'",
 683                  PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 684                OPT_END(),
 685        };
 686        int has_dash_dash;
 687
 688        memset(&opts, 0, sizeof(opts));
 689        memset(&new, 0, sizeof(new));
 690
 691        git_config(git_checkout_config, NULL);
 692
 693        opts.track = BRANCH_TRACK_UNSPECIFIED;
 694
 695        argc = parse_options(argc, argv, prefix, options, checkout_usage,
 696                             PARSE_OPT_KEEP_DASHDASH);
 697
 698        /* we can assume from now on new_branch = !new_branch_force */
 699        if (opts.new_branch && opts.new_branch_force)
 700                die("-B cannot be used with -b");
 701
 702        /* copy -B over to -b, so that we can just check the latter */
 703        if (opts.new_branch_force)
 704                opts.new_branch = opts.new_branch_force;
 705
 706        if (patch_mode && (opts.track > 0 || opts.new_branch
 707                           || opts.new_branch_log || opts.merge || opts.force))
 708                die ("--patch is incompatible with all other options");
 709
 710        /* --track without -b should DWIM */
 711        if (0 < opts.track && !opts.new_branch) {
 712                const char *argv0 = argv[0];
 713                if (!argc || !strcmp(argv0, "--"))
 714                        die ("--track needs a branch name");
 715                if (!prefixcmp(argv0, "refs/"))
 716                        argv0 += 5;
 717                if (!prefixcmp(argv0, "remotes/"))
 718                        argv0 += 8;
 719                argv0 = strchr(argv0, '/');
 720                if (!argv0 || !argv0[1])
 721                        die ("Missing branch name; try -b");
 722                opts.new_branch = argv0 + 1;
 723        }
 724
 725        if (opts.new_orphan_branch) {
 726                if (opts.new_branch)
 727                        die("--orphan and -b|-B are mutually exclusive");
 728                if (opts.track > 0)
 729                        die("--orphan cannot be used with -t");
 730                opts.new_branch = opts.new_orphan_branch;
 731        }
 732
 733        if (conflict_style) {
 734                opts.merge = 1; /* implied */
 735                git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 736        }
 737
 738        if (opts.force && opts.merge)
 739                die("git checkout: -f and -m are incompatible");
 740
 741        /*
 742         * case 1: git checkout <ref> -- [<paths>]
 743         *
 744         *   <ref> must be a valid tree, everything after the '--' must be
 745         *   a path.
 746         *
 747         * case 2: git checkout -- [<paths>]
 748         *
 749         *   everything after the '--' must be paths.
 750         *
 751         * case 3: git checkout <something> [<paths>]
 752         *
 753         *   With no paths, if <something> is a commit, that is to
 754         *   switch to the branch or detach HEAD at it.  As a special case,
 755         *   if <something> is A...B (missing A or B means HEAD but you can
 756         *   omit at most one side), and if there is a unique merge base
 757         *   between A and B, A...B names that merge base.
 758         *
 759         *   With no paths, if <something> is _not_ a commit, no -t nor -b
 760         *   was given, and there is a tracking branch whose name is
 761         *   <something> in one and only one remote, then this is a short-hand
 762         *   to fork local <something> from that remote tracking branch.
 763         *
 764         *   Otherwise <something> shall not be ambiguous.
 765         *   - If it's *only* a reference, treat it like case (1).
 766         *   - If it's only a path, treat it like case (2).
 767         *   - else: fail.
 768         *
 769         */
 770        if (argc) {
 771                if (!strcmp(argv[0], "--")) {       /* case (2) */
 772                        argv++;
 773                        argc--;
 774                        goto no_reference;
 775                }
 776
 777                arg = argv[0];
 778                has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 779
 780                if (!strcmp(arg, "-"))
 781                        arg = "@{-1}";
 782
 783                if (get_sha1_mb(arg, rev)) {
 784                        if (has_dash_dash)          /* case (1) */
 785                                die("invalid reference: %s", arg);
 786                        if (!patch_mode &&
 787                            dwim_new_local_branch &&
 788                            opts.track == BRANCH_TRACK_UNSPECIFIED &&
 789                            !opts.new_branch &&
 790                            !check_filename(NULL, arg) &&
 791                            argc == 1) {
 792                                const char *remote = unique_tracking_name(arg);
 793                                if (!remote || get_sha1(remote, rev))
 794                                        goto no_reference;
 795                                opts.new_branch = arg;
 796                                arg = remote;
 797                                /* DWIMmed to create local branch */
 798                        }
 799                        else
 800                                goto no_reference;
 801                }
 802
 803                /* we can't end up being in (2) anymore, eat the argument */
 804                argv++;
 805                argc--;
 806
 807                new.name = arg;
 808                if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 809                        setup_branch_path(&new);
 810
 811                        if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 812                            resolve_ref(new.path, rev, 1, NULL))
 813                                ;
 814                        else
 815                                new.path = NULL;
 816                        parse_commit(new.commit);
 817                        source_tree = new.commit->tree;
 818                } else
 819                        source_tree = parse_tree_indirect(rev);
 820
 821                if (!source_tree)                   /* case (1): want a tree */
 822                        die("reference is not a tree: %s", arg);
 823                if (!has_dash_dash) {/* case (3 -> 1) */
 824                        /*
 825                         * Do not complain the most common case
 826                         *      git checkout branch
 827                         * even if there happen to be a file called 'branch';
 828                         * it would be extremely annoying.
 829                         */
 830                        if (argc)
 831                                verify_non_filename(NULL, arg);
 832                }
 833                else {
 834                        argv++;
 835                        argc--;
 836                }
 837        }
 838
 839no_reference:
 840
 841        if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 842                opts.track = git_branch_track;
 843
 844        if (argc) {
 845                const char **pathspec = get_pathspec(prefix, argv);
 846
 847                if (!pathspec)
 848                        die("invalid path specification");
 849
 850                if (patch_mode)
 851                        return interactive_checkout(new.name, pathspec, &opts);
 852
 853                /* Checkout paths */
 854                if (opts.new_branch) {
 855                        if (argc == 1) {
 856                                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]);
 857                        } else {
 858                                die("git checkout: updating paths is incompatible with switching branches.");
 859                        }
 860                }
 861
 862                if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 863                        die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 864
 865                return checkout_paths(source_tree, pathspec, &opts);
 866        }
 867
 868        if (patch_mode)
 869                return interactive_checkout(new.name, NULL, &opts);
 870
 871        if (opts.new_branch) {
 872                struct strbuf buf = STRBUF_INIT;
 873                if (strbuf_check_branch_ref(&buf, opts.new_branch))
 874                        die("git checkout: we do not like '%s' as a branch name.",
 875                            opts.new_branch);
 876                if (!get_sha1(buf.buf, rev)) {
 877                        opts.branch_exists = 1;
 878                        if (!opts.new_branch_force)
 879                                die("git checkout: branch %s already exists",
 880                                    opts.new_branch);
 881                }
 882                strbuf_release(&buf);
 883        }
 884
 885        if (new.name && !new.commit) {
 886                die("Cannot switch branch to a non-commit.");
 887        }
 888        if (opts.writeout_stage)
 889                die("--ours/--theirs is incompatible with switching branches.");
 890
 891        return switch_branches(&opts, &new);
 892}