e73bfe3403e0d80aced9607321792bb60779b109
   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#include "submodule.h"
  22
  23static const char * const checkout_usage[] = {
  24        "git checkout [options] <branch>",
  25        "git checkout [options] [<branch>] -- <file>...",
  26        NULL,
  27};
  28
  29struct checkout_opts {
  30        int quiet;
  31        int merge;
  32        int force;
  33        int writeout_stage;
  34        int writeout_error;
  35
  36        const char *new_branch;
  37        const char *new_orphan_branch;
  38        int new_branch_log;
  39        enum branch_track track;
  40        struct diff_options diff_options;
  41};
  42
  43static int post_checkout_hook(struct commit *old, struct commit *new,
  44                              int changed)
  45{
  46        return run_hook(NULL, "post-checkout",
  47                        sha1_to_hex(old ? old->object.sha1 : null_sha1),
  48                        sha1_to_hex(new ? new->object.sha1 : null_sha1),
  49                        changed ? "1" : "0", NULL);
  50        /* "new" can be NULL when checking out from the index before
  51           a commit exists. */
  52
  53}
  54
  55static int update_some(const unsigned char *sha1, const char *base, int baselen,
  56                const char *pathname, unsigned mode, int stage, void *context)
  57{
  58        int len;
  59        struct cache_entry *ce;
  60
  61        if (S_ISDIR(mode))
  62                return READ_TREE_RECURSIVE;
  63
  64        len = baselen + strlen(pathname);
  65        ce = xcalloc(1, cache_entry_size(len));
  66        hashcpy(ce->sha1, sha1);
  67        memcpy(ce->name, base, baselen);
  68        memcpy(ce->name + baselen, pathname, len - baselen);
  69        ce->ce_flags = create_ce_flags(len, 0);
  70        ce->ce_mode = create_ce_mode(mode);
  71        add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
  72        return 0;
  73}
  74
  75static int read_tree_some(struct tree *tree, const char **pathspec)
  76{
  77        read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
  78
  79        /* update the index with the given tree's info
  80         * for all args, expanding wildcards, and exit
  81         * with any non-zero return code.
  82         */
  83        return 0;
  84}
  85
  86static int skip_same_name(struct cache_entry *ce, int pos)
  87{
  88        while (++pos < active_nr &&
  89               !strcmp(active_cache[pos]->name, ce->name))
  90                ; /* skip */
  91        return pos;
  92}
  93
  94static int check_stage(int stage, struct cache_entry *ce, int pos)
  95{
  96        while (pos < active_nr &&
  97               !strcmp(active_cache[pos]->name, ce->name)) {
  98                if (ce_stage(active_cache[pos]) == stage)
  99                        return 0;
 100                pos++;
 101        }
 102        return error("path '%s' does not have %s version",
 103                     ce->name,
 104                     (stage == 2) ? "our" : "their");
 105}
 106
 107static int check_all_stages(struct cache_entry *ce, int pos)
 108{
 109        if (ce_stage(ce) != 1 ||
 110            active_nr <= pos + 2 ||
 111            strcmp(active_cache[pos+1]->name, ce->name) ||
 112            ce_stage(active_cache[pos+1]) != 2 ||
 113            strcmp(active_cache[pos+2]->name, ce->name) ||
 114            ce_stage(active_cache[pos+2]) != 3)
 115                return error("path '%s' does not have all three versions",
 116                             ce->name);
 117        return 0;
 118}
 119
 120static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 121                          struct checkout *state)
 122{
 123        while (pos < active_nr &&
 124               !strcmp(active_cache[pos]->name, ce->name)) {
 125                if (ce_stage(active_cache[pos]) == stage)
 126                        return checkout_entry(active_cache[pos], state, NULL);
 127                pos++;
 128        }
 129        return error("path '%s' does not have %s version",
 130                     ce->name,
 131                     (stage == 2) ? "our" : "their");
 132}
 133
 134static int checkout_merged(int pos, struct checkout *state)
 135{
 136        struct cache_entry *ce = active_cache[pos];
 137        const char *path = ce->name;
 138        mmfile_t ancestor, ours, theirs;
 139        int status;
 140        unsigned char sha1[20];
 141        mmbuffer_t result_buf;
 142
 143        if (ce_stage(ce) != 1 ||
 144            active_nr <= pos + 2 ||
 145            strcmp(active_cache[pos+1]->name, path) ||
 146            ce_stage(active_cache[pos+1]) != 2 ||
 147            strcmp(active_cache[pos+2]->name, path) ||
 148            ce_stage(active_cache[pos+2]) != 3)
 149                return error("path '%s' does not have all 3 versions", path);
 150
 151        read_mmblob(&ancestor, active_cache[pos]->sha1);
 152        read_mmblob(&ours, active_cache[pos+1]->sha1);
 153        read_mmblob(&theirs, active_cache[pos+2]->sha1);
 154
 155        status = ll_merge(&result_buf, path, &ancestor, "base",
 156                          &ours, "ours", &theirs, "theirs", 0);
 157        free(ancestor.ptr);
 158        free(ours.ptr);
 159        free(theirs.ptr);
 160        if (status < 0 || !result_buf.ptr) {
 161                free(result_buf.ptr);
 162                return error("path '%s': cannot merge", path);
 163        }
 164
 165        /*
 166         * NEEDSWORK:
 167         * There is absolutely no reason to write this as a blob object
 168         * and create a phony cache entry just to leak.  This hack is
 169         * primarily to get to the write_entry() machinery that massages
 170         * the contents to work-tree format and writes out which only
 171         * allows it for a cache entry.  The code in write_entry() needs
 172         * to be refactored to allow us to feed a <buffer, size, mode>
 173         * instead of a cache entry.  Such a refactoring would help
 174         * merge_recursive as well (it also writes the merge result to the
 175         * object database even when it may contain conflicts).
 176         */
 177        if (write_sha1_file(result_buf.ptr, result_buf.size,
 178                            blob_type, sha1))
 179                die("Unable to add merge result for '%s'", path);
 180        ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
 181                              sha1,
 182                              path, 2, 0);
 183        if (!ce)
 184                die("make_cache_entry failed for path '%s'", path);
 185        status = checkout_entry(ce, state, NULL);
 186        return status;
 187}
 188
 189static int checkout_paths(struct tree *source_tree, const char **pathspec,
 190                          struct checkout_opts *opts)
 191{
 192        int pos;
 193        struct checkout state;
 194        static char *ps_matched;
 195        unsigned char rev[20];
 196        int flag;
 197        struct commit *head;
 198        int errs = 0;
 199        int stage = opts->writeout_stage;
 200        int merge = opts->merge;
 201        int newfd;
 202        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 203
 204        newfd = hold_locked_index(lock_file, 1);
 205        if (read_cache_preload(pathspec) < 0)
 206                return error("corrupt index file");
 207
 208        if (source_tree)
 209                read_tree_some(source_tree, pathspec);
 210
 211        for (pos = 0; pathspec[pos]; pos++)
 212                ;
 213        ps_matched = xcalloc(1, pos);
 214
 215        for (pos = 0; pos < active_nr; pos++) {
 216                struct cache_entry *ce = active_cache[pos];
 217                match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
 218        }
 219
 220        if (report_path_error(ps_matched, pathspec, 0))
 221                return 1;
 222
 223        /* "checkout -m path" to recreate conflicted state */
 224        if (opts->merge)
 225                unmerge_cache(pathspec);
 226
 227        /* Any unmerged paths? */
 228        for (pos = 0; pos < active_nr; pos++) {
 229                struct cache_entry *ce = active_cache[pos];
 230                if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 231                        if (!ce_stage(ce))
 232                                continue;
 233                        if (opts->force) {
 234                                warning("path '%s' is unmerged", ce->name);
 235                        } else if (stage) {
 236                                errs |= check_stage(stage, ce, pos);
 237                        } else if (opts->merge) {
 238                                errs |= check_all_stages(ce, pos);
 239                        } else {
 240                                errs = 1;
 241                                error("path '%s' is unmerged", ce->name);
 242                        }
 243                        pos = skip_same_name(ce, pos) - 1;
 244                }
 245        }
 246        if (errs)
 247                return 1;
 248
 249        /* Now we are committed to check them out */
 250        memset(&state, 0, sizeof(state));
 251        state.force = 1;
 252        state.refresh_cache = 1;
 253        for (pos = 0; pos < active_nr; pos++) {
 254                struct cache_entry *ce = active_cache[pos];
 255                if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 256                        if (!ce_stage(ce)) {
 257                                errs |= checkout_entry(ce, &state, NULL);
 258                                continue;
 259                        }
 260                        if (stage)
 261                                errs |= checkout_stage(stage, ce, pos, &state);
 262                        else if (merge)
 263                                errs |= checkout_merged(pos, &state);
 264                        pos = skip_same_name(ce, pos) - 1;
 265                }
 266        }
 267
 268        if (write_cache(newfd, active_cache, active_nr) ||
 269            commit_locked_index(lock_file))
 270                die("unable to write new index file");
 271
 272        resolve_ref("HEAD", rev, 0, &flag);
 273        head = lookup_commit_reference_gently(rev, 1);
 274
 275        errs |= post_checkout_hook(head, head, 0);
 276        return errs;
 277}
 278
 279static void show_local_changes(struct object *head, struct diff_options *opts)
 280{
 281        struct rev_info rev;
 282        /* I think we want full paths, even if we're in a subdirectory. */
 283        init_revisions(&rev, NULL);
 284        rev.abbrev = 0;
 285        rev.diffopt.flags = opts->flags;
 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, &opts->diff_options);
 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, 0,
 518                                      opts->new_branch_log, opts->track);
 519                new->name = opts->new_branch;
 520                setup_branch_path(new);
 521        }
 522
 523        old_desc = old->name;
 524        if (!old_desc && old->commit)
 525                old_desc = sha1_to_hex(old->commit->object.sha1);
 526        strbuf_addf(&msg, "checkout: moving from %s to %s",
 527                    old_desc ? old_desc : "(invalid)", new->name);
 528
 529        if (new->path) {
 530                create_symref("HEAD", new->path, msg.buf);
 531                if (!opts->quiet) {
 532                        if (old->path && !strcmp(new->path, old->path))
 533                                fprintf(stderr, "Already on '%s'\n",
 534                                        new->name);
 535                        else
 536                                fprintf(stderr, "Switched to%s branch '%s'\n",
 537                                        opts->new_branch ? " a new" : "",
 538                                        new->name);
 539                }
 540                if (old->path && old->name) {
 541                        char log_file[PATH_MAX], ref_file[PATH_MAX];
 542
 543                        git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 544                        git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 545                        if (!file_exists(ref_file) && file_exists(log_file))
 546                                remove_path(log_file);
 547                }
 548        } else if (strcmp(new->name, "HEAD")) {
 549                update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 550                           REF_NODEREF, DIE_ON_ERR);
 551                if (!opts->quiet) {
 552                        if (old->path && advice_detached_head)
 553                                detach_advice(old->path, new->name);
 554                        describe_detached_head("HEAD is now at", new->commit);
 555                }
 556        }
 557        remove_branch_state();
 558        strbuf_release(&msg);
 559        if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 560                report_tracking(new);
 561}
 562
 563static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 564{
 565        int ret = 0;
 566        struct branch_info old;
 567        unsigned char rev[20];
 568        int flag;
 569        memset(&old, 0, sizeof(old));
 570        old.path = resolve_ref("HEAD", rev, 0, &flag);
 571        old.commit = lookup_commit_reference_gently(rev, 1);
 572        if (!(flag & REF_ISSYMREF))
 573                old.path = NULL;
 574
 575        if (old.path && !prefixcmp(old.path, "refs/heads/"))
 576                old.name = old.path + strlen("refs/heads/");
 577
 578        if (!new->name) {
 579                new->name = "HEAD";
 580                new->commit = old.commit;
 581                if (!new->commit)
 582                        die("You are on a branch yet to be born");
 583                parse_commit(new->commit);
 584        }
 585
 586        ret = merge_working_tree(opts, &old, new);
 587        if (ret)
 588                return ret;
 589
 590        /*
 591         * If we were on a detached HEAD, but have now moved to
 592         * a new commit, we want to mention the old commit once more
 593         * to remind the user that it might be lost.
 594         */
 595        if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 596                describe_detached_head("Previous HEAD position was", old.commit);
 597
 598        update_refs_for_switch(opts, &old, new);
 599
 600        ret = post_checkout_hook(old.commit, new->commit, 1);
 601        return ret || opts->writeout_error;
 602}
 603
 604static int git_checkout_config(const char *var, const char *value, void *cb)
 605{
 606        if (!strcmp(var, "diff.ignoresubmodules")) {
 607                struct checkout_opts *opts = cb;
 608                handle_ignore_submodules_arg(&opts->diff_options, value);
 609                return 0;
 610        }
 611        return git_xmerge_config(var, value, NULL);
 612}
 613
 614static 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
 620struct tracking_name_data {
 621        const char *name;
 622        char *remote;
 623        int unique;
 624};
 625
 626static 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
 645static 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
 656int 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, "new branch", "branch"),
 669                OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 670                OPT_SET_INT('t', "track",  &opts.track, "track",
 671                        BRANCH_TRACK_EXPLICIT),
 672                OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 673                OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 674                            2),
 675                OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 676                            3),
 677                OPT_BOOLEAN('f', "force", &opts.force, "force"),
 678                OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 679                OPT_STRING(0, "conflict", &conflict_style, "style",
 680                           "conflict style (merge or diff3)"),
 681                OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 682                { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 683                  "second guess 'git checkout no-such-branch'",
 684                  PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 685                OPT_END(),
 686        };
 687        int has_dash_dash;
 688
 689        memset(&opts, 0, sizeof(opts));
 690        memset(&new, 0, sizeof(new));
 691
 692        git_config(git_checkout_config, &opts);
 693
 694        opts.track = BRANCH_TRACK_UNSPECIFIED;
 695
 696        argc = parse_options(argc, argv, prefix, options, checkout_usage,
 697                             PARSE_OPT_KEEP_DASHDASH);
 698
 699        if (patch_mode && (opts.track > 0 || opts.new_branch
 700                           || opts.new_branch_log || opts.merge || opts.force))
 701                die ("--patch is incompatible with all other options");
 702
 703        /* --track without -b should DWIM */
 704        if (0 < opts.track && !opts.new_branch) {
 705                const char *argv0 = argv[0];
 706                if (!argc || !strcmp(argv0, "--"))
 707                        die ("--track needs a branch name");
 708                if (!prefixcmp(argv0, "refs/"))
 709                        argv0 += 5;
 710                if (!prefixcmp(argv0, "remotes/"))
 711                        argv0 += 8;
 712                argv0 = strchr(argv0, '/');
 713                if (!argv0 || !argv0[1])
 714                        die ("Missing branch name; try -b");
 715                opts.new_branch = argv0 + 1;
 716        }
 717
 718        if (opts.new_orphan_branch) {
 719                if (opts.new_branch)
 720                        die("--orphan and -b are mutually exclusive");
 721                if (opts.track > 0)
 722                        die("--orphan cannot be used with -t");
 723                opts.new_branch = opts.new_orphan_branch;
 724        }
 725
 726        if (conflict_style) {
 727                opts.merge = 1; /* implied */
 728                git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 729        }
 730
 731        if (opts.force && opts.merge)
 732                die("git checkout: -f and -m are incompatible");
 733
 734        /*
 735         * case 1: git checkout <ref> -- [<paths>]
 736         *
 737         *   <ref> must be a valid tree, everything after the '--' must be
 738         *   a path.
 739         *
 740         * case 2: git checkout -- [<paths>]
 741         *
 742         *   everything after the '--' must be paths.
 743         *
 744         * case 3: git checkout <something> [<paths>]
 745         *
 746         *   With no paths, if <something> is a commit, that is to
 747         *   switch to the branch or detach HEAD at it.  As a special case,
 748         *   if <something> is A...B (missing A or B means HEAD but you can
 749         *   omit at most one side), and if there is a unique merge base
 750         *   between A and B, A...B names that merge base.
 751         *
 752         *   With no paths, if <something> is _not_ a commit, no -t nor -b
 753         *   was given, and there is a tracking branch whose name is
 754         *   <something> in one and only one remote, then this is a short-hand
 755         *   to fork local <something> from that remote tracking branch.
 756         *
 757         *   Otherwise <something> shall not be ambiguous.
 758         *   - If it's *only* a reference, treat it like case (1).
 759         *   - If it's only a path, treat it like case (2).
 760         *   - else: fail.
 761         *
 762         */
 763        if (argc) {
 764                if (!strcmp(argv[0], "--")) {       /* case (2) */
 765                        argv++;
 766                        argc--;
 767                        goto no_reference;
 768                }
 769
 770                arg = argv[0];
 771                has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 772
 773                if (!strcmp(arg, "-"))
 774                        arg = "@{-1}";
 775
 776                if (get_sha1_mb(arg, rev)) {
 777                        if (has_dash_dash)          /* case (1) */
 778                                die("invalid reference: %s", arg);
 779                        if (!patch_mode &&
 780                            dwim_new_local_branch &&
 781                            opts.track == BRANCH_TRACK_UNSPECIFIED &&
 782                            !opts.new_branch &&
 783                            !check_filename(NULL, arg) &&
 784                            argc == 1) {
 785                                const char *remote = unique_tracking_name(arg);
 786                                if (!remote || get_sha1(remote, rev))
 787                                        goto no_reference;
 788                                opts.new_branch = arg;
 789                                arg = remote;
 790                                /* DWIMmed to create local branch */
 791                        }
 792                        else
 793                                goto no_reference;
 794                }
 795
 796                /* we can't end up being in (2) anymore, eat the argument */
 797                argv++;
 798                argc--;
 799
 800                new.name = arg;
 801                if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 802                        setup_branch_path(&new);
 803
 804                        if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 805                            resolve_ref(new.path, rev, 1, NULL))
 806                                ;
 807                        else
 808                                new.path = NULL;
 809                        parse_commit(new.commit);
 810                        source_tree = new.commit->tree;
 811                } else
 812                        source_tree = parse_tree_indirect(rev);
 813
 814                if (!source_tree)                   /* case (1): want a tree */
 815                        die("reference is not a tree: %s", arg);
 816                if (!has_dash_dash) {/* case (3 -> 1) */
 817                        /*
 818                         * Do not complain the most common case
 819                         *      git checkout branch
 820                         * even if there happen to be a file called 'branch';
 821                         * it would be extremely annoying.
 822                         */
 823                        if (argc)
 824                                verify_non_filename(NULL, arg);
 825                }
 826                else {
 827                        argv++;
 828                        argc--;
 829                }
 830        }
 831
 832no_reference:
 833
 834        if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 835                opts.track = git_branch_track;
 836
 837        if (argc) {
 838                const char **pathspec = get_pathspec(prefix, argv);
 839
 840                if (!pathspec)
 841                        die("invalid path specification");
 842
 843                if (patch_mode)
 844                        return interactive_checkout(new.name, pathspec, &opts);
 845
 846                /* Checkout paths */
 847                if (opts.new_branch) {
 848                        if (argc == 1) {
 849                                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]);
 850                        } else {
 851                                die("git checkout: updating paths is incompatible with switching branches.");
 852                        }
 853                }
 854
 855                if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 856                        die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 857
 858                return checkout_paths(source_tree, pathspec, &opts);
 859        }
 860
 861        if (patch_mode)
 862                return interactive_checkout(new.name, NULL, &opts);
 863
 864        if (opts.new_branch) {
 865                struct strbuf buf = STRBUF_INIT;
 866                if (strbuf_check_branch_ref(&buf, opts.new_branch))
 867                        die("git checkout: we do not like '%s' as a branch name.",
 868                            opts.new_branch);
 869                if (!get_sha1(buf.buf, rev))
 870                        die("git checkout: branch %s already exists", opts.new_branch);
 871                strbuf_release(&buf);
 872        }
 873
 874        if (new.name && !new.commit) {
 875                die("Cannot switch branch to a non-commit.");
 876        }
 877        if (opts.writeout_stage)
 878                die("--ours/--theirs is incompatible with switching branches.");
 879
 880        return switch_branches(&opts, &new);
 881}