builtin-checkout.con commit Merge branch 'cb/maint-merge-recursive-submodule-fix' (2149e0f)
   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 "unpack-trees.h"
   9#include "dir.h"
  10#include "run-command.h"
  11#include "merge-recursive.h"
  12#include "branch.h"
  13#include "diff.h"
  14#include "revision.h"
  15#include "remote.h"
  16#include "blob.h"
  17#include "xdiff-interface.h"
  18#include "ll-merge.h"
  19
  20static const char * const checkout_usage[] = {
  21        "git checkout [options] <branch>",
  22        "git checkout [options] [<branch>] -- <file>...",
  23        NULL,
  24};
  25
  26struct checkout_opts {
  27        int quiet;
  28        int merge;
  29        int force;
  30        int writeout_stage;
  31        int writeout_error;
  32
  33        const char *new_branch;
  34        int new_branch_log;
  35        enum branch_track track;
  36};
  37
  38static int post_checkout_hook(struct commit *old, struct commit *new,
  39                              int changed)
  40{
  41        return run_hook(NULL, "post-checkout",
  42                        sha1_to_hex(old ? old->object.sha1 : null_sha1),
  43                        sha1_to_hex(new ? new->object.sha1 : null_sha1),
  44                        changed ? "1" : "0", NULL);
  45        /* "new" can be NULL when checking out from the index before
  46           a commit exists. */
  47
  48}
  49
  50static int update_some(const unsigned char *sha1, const char *base, int baselen,
  51                const char *pathname, unsigned mode, int stage, void *context)
  52{
  53        int len;
  54        struct cache_entry *ce;
  55
  56        if (S_ISGITLINK(mode))
  57                return 0;
  58
  59        if (S_ISDIR(mode))
  60                return READ_TREE_RECURSIVE;
  61
  62        len = baselen + strlen(pathname);
  63        ce = xcalloc(1, cache_entry_size(len));
  64        hashcpy(ce->sha1, sha1);
  65        memcpy(ce->name, base, baselen);
  66        memcpy(ce->name + baselen, pathname, len - baselen);
  67        ce->ce_flags = create_ce_flags(len, 0);
  68        ce->ce_mode = create_ce_mode(mode);
  69        add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
  70        return 0;
  71}
  72
  73static int read_tree_some(struct tree *tree, const char **pathspec)
  74{
  75        read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
  76
  77        /* update the index with the given tree's info
  78         * for all args, expanding wildcards, and exit
  79         * with any non-zero return code.
  80         */
  81        return 0;
  82}
  83
  84static int skip_same_name(struct cache_entry *ce, int pos)
  85{
  86        while (++pos < active_nr &&
  87               !strcmp(active_cache[pos]->name, ce->name))
  88                ; /* skip */
  89        return pos;
  90}
  91
  92static int check_stage(int stage, struct cache_entry *ce, int pos)
  93{
  94        while (pos < active_nr &&
  95               !strcmp(active_cache[pos]->name, ce->name)) {
  96                if (ce_stage(active_cache[pos]) == stage)
  97                        return 0;
  98                pos++;
  99        }
 100        return error("path '%s' does not have %s version",
 101                     ce->name,
 102                     (stage == 2) ? "our" : "their");
 103}
 104
 105static int check_all_stages(struct cache_entry *ce, int pos)
 106{
 107        if (ce_stage(ce) != 1 ||
 108            active_nr <= pos + 2 ||
 109            strcmp(active_cache[pos+1]->name, ce->name) ||
 110            ce_stage(active_cache[pos+1]) != 2 ||
 111            strcmp(active_cache[pos+2]->name, ce->name) ||
 112            ce_stage(active_cache[pos+2]) != 3)
 113                return error("path '%s' does not have all three versions",
 114                             ce->name);
 115        return 0;
 116}
 117
 118static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 119                          struct checkout *state)
 120{
 121        while (pos < active_nr &&
 122               !strcmp(active_cache[pos]->name, ce->name)) {
 123                if (ce_stage(active_cache[pos]) == stage)
 124                        return checkout_entry(active_cache[pos], state, NULL);
 125                pos++;
 126        }
 127        return error("path '%s' does not have %s version",
 128                     ce->name,
 129                     (stage == 2) ? "our" : "their");
 130}
 131
 132/* NEEDSWORK: share with merge-recursive */
 133static void fill_mm(const unsigned char *sha1, mmfile_t *mm)
 134{
 135        unsigned long size;
 136        enum object_type type;
 137
 138        if (!hashcmp(sha1, null_sha1)) {
 139                mm->ptr = xstrdup("");
 140                mm->size = 0;
 141                return;
 142        }
 143
 144        mm->ptr = read_sha1_file(sha1, &type, &size);
 145        if (!mm->ptr || type != OBJ_BLOB)
 146                die("unable to read blob object %s", sha1_to_hex(sha1));
 147        mm->size = size;
 148}
 149
 150static int checkout_merged(int pos, struct checkout *state)
 151{
 152        struct cache_entry *ce = active_cache[pos];
 153        const char *path = ce->name;
 154        mmfile_t ancestor, ours, theirs;
 155        int status;
 156        unsigned char sha1[20];
 157        mmbuffer_t result_buf;
 158
 159        if (ce_stage(ce) != 1 ||
 160            active_nr <= pos + 2 ||
 161            strcmp(active_cache[pos+1]->name, path) ||
 162            ce_stage(active_cache[pos+1]) != 2 ||
 163            strcmp(active_cache[pos+2]->name, path) ||
 164            ce_stage(active_cache[pos+2]) != 3)
 165                return error("path '%s' does not have all 3 versions", path);
 166
 167        fill_mm(active_cache[pos]->sha1, &ancestor);
 168        fill_mm(active_cache[pos+1]->sha1, &ours);
 169        fill_mm(active_cache[pos+2]->sha1, &theirs);
 170
 171        status = ll_merge(&result_buf, path, &ancestor,
 172                          &ours, "ours", &theirs, "theirs", 1);
 173        free(ancestor.ptr);
 174        free(ours.ptr);
 175        free(theirs.ptr);
 176        if (status < 0 || !result_buf.ptr) {
 177                free(result_buf.ptr);
 178                return error("path '%s': cannot merge", path);
 179        }
 180
 181        /*
 182         * NEEDSWORK:
 183         * There is absolutely no reason to write this as a blob object
 184         * and create a phoney cache entry just to leak.  This hack is
 185         * primarily to get to the write_entry() machinery that massages
 186         * the contents to work-tree format and writes out which only
 187         * allows it for a cache entry.  The code in write_entry() needs
 188         * to be refactored to allow us to feed a <buffer, size, mode>
 189         * instead of a cache entry.  Such a refactoring would help
 190         * merge_recursive as well (it also writes the merge result to the
 191         * object database even when it may contain conflicts).
 192         */
 193        if (write_sha1_file(result_buf.ptr, result_buf.size,
 194                            blob_type, sha1))
 195                die("Unable to add merge result for '%s'", path);
 196        ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
 197                              sha1,
 198                              path, 2, 0);
 199        if (!ce)
 200                die("make_cache_entry failed for path '%s'", path);
 201        status = checkout_entry(ce, state, NULL);
 202        return status;
 203}
 204
 205static int checkout_paths(struct tree *source_tree, const char **pathspec,
 206                          struct checkout_opts *opts)
 207{
 208        int pos;
 209        struct checkout state;
 210        static char *ps_matched;
 211        unsigned char rev[20];
 212        int flag;
 213        struct commit *head;
 214        int errs = 0;
 215        int stage = opts->writeout_stage;
 216        int merge = opts->merge;
 217        int newfd;
 218        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 219
 220        newfd = hold_locked_index(lock_file, 1);
 221        if (read_cache() < 0)
 222                return error("corrupt index file");
 223
 224        if (source_tree)
 225                read_tree_some(source_tree, pathspec);
 226
 227        for (pos = 0; pathspec[pos]; pos++)
 228                ;
 229        ps_matched = xcalloc(1, pos);
 230
 231        for (pos = 0; pos < active_nr; pos++) {
 232                struct cache_entry *ce = active_cache[pos];
 233                match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
 234        }
 235
 236        if (report_path_error(ps_matched, pathspec, 0))
 237                return 1;
 238
 239        /* Any unmerged paths? */
 240        for (pos = 0; pos < active_nr; pos++) {
 241                struct cache_entry *ce = active_cache[pos];
 242                if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 243                        if (!ce_stage(ce))
 244                                continue;
 245                        if (opts->force) {
 246                                warning("path '%s' is unmerged", ce->name);
 247                        } else if (stage) {
 248                                errs |= check_stage(stage, ce, pos);
 249                        } else if (opts->merge) {
 250                                errs |= check_all_stages(ce, pos);
 251                        } else {
 252                                errs = 1;
 253                                error("path '%s' is unmerged", ce->name);
 254                        }
 255                        pos = skip_same_name(ce, pos) - 1;
 256                }
 257        }
 258        if (errs)
 259                return 1;
 260
 261        /* Now we are committed to check them out */
 262        memset(&state, 0, sizeof(state));
 263        state.force = 1;
 264        state.refresh_cache = 1;
 265        for (pos = 0; pos < active_nr; pos++) {
 266                struct cache_entry *ce = active_cache[pos];
 267                if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 268                        if (!ce_stage(ce)) {
 269                                errs |= checkout_entry(ce, &state, NULL);
 270                                continue;
 271                        }
 272                        if (stage)
 273                                errs |= checkout_stage(stage, ce, pos, &state);
 274                        else if (merge)
 275                                errs |= checkout_merged(pos, &state);
 276                        pos = skip_same_name(ce, pos) - 1;
 277                }
 278        }
 279
 280        if (write_cache(newfd, active_cache, active_nr) ||
 281            commit_locked_index(lock_file))
 282                die("unable to write new index file");
 283
 284        resolve_ref("HEAD", rev, 0, &flag);
 285        head = lookup_commit_reference_gently(rev, 1);
 286
 287        errs |= post_checkout_hook(head, head, 0);
 288        return errs;
 289}
 290
 291static void show_local_changes(struct object *head)
 292{
 293        struct rev_info rev;
 294        /* I think we want full paths, even if we're in a subdirectory. */
 295        init_revisions(&rev, NULL);
 296        rev.abbrev = 0;
 297        rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 298        if (diff_setup_done(&rev.diffopt) < 0)
 299                die("diff_setup_done failed");
 300        add_pending_object(&rev, head, NULL);
 301        run_diff_index(&rev, 0);
 302}
 303
 304static void describe_detached_head(char *msg, struct commit *commit)
 305{
 306        struct strbuf sb = STRBUF_INIT;
 307        parse_commit(commit);
 308        pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, 0, NULL, NULL, 0, 0);
 309        fprintf(stderr, "%s %s... %s\n", msg,
 310                find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
 311        strbuf_release(&sb);
 312}
 313
 314static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
 315{
 316        struct unpack_trees_options opts;
 317        struct tree_desc tree_desc;
 318
 319        memset(&opts, 0, sizeof(opts));
 320        opts.head_idx = -1;
 321        opts.update = worktree;
 322        opts.skip_unmerged = !worktree;
 323        opts.reset = 1;
 324        opts.merge = 1;
 325        opts.fn = oneway_merge;
 326        opts.verbose_update = !o->quiet;
 327        opts.src_index = &the_index;
 328        opts.dst_index = &the_index;
 329        parse_tree(tree);
 330        init_tree_desc(&tree_desc, tree->buffer, tree->size);
 331        switch (unpack_trees(1, &tree_desc, &opts)) {
 332        case -2:
 333                o->writeout_error = 1;
 334                /*
 335                 * We return 0 nevertheless, as the index is all right
 336                 * and more importantly we have made best efforts to
 337                 * update paths in the work tree, and we cannot revert
 338                 * them.
 339                 */
 340        case 0:
 341                return 0;
 342        default:
 343                return 128;
 344        }
 345}
 346
 347struct branch_info {
 348        const char *name; /* The short name used */
 349        const char *path; /* The full name of a real branch */
 350        struct commit *commit; /* The named commit */
 351};
 352
 353static void setup_branch_path(struct branch_info *branch)
 354{
 355        struct strbuf buf = STRBUF_INIT;
 356
 357        strbuf_branchname(&buf, branch->name);
 358        if (strcmp(buf.buf, branch->name))
 359                branch->name = xstrdup(buf.buf);
 360        strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 361        branch->path = strbuf_detach(&buf, NULL);
 362}
 363
 364static int merge_working_tree(struct checkout_opts *opts,
 365                              struct branch_info *old, struct branch_info *new)
 366{
 367        int ret;
 368        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 369        int newfd = hold_locked_index(lock_file, 1);
 370
 371        if (read_cache() < 0)
 372                return error("corrupt index file");
 373
 374        if (opts->force) {
 375                ret = reset_tree(new->commit->tree, opts, 1);
 376                if (ret)
 377                        return ret;
 378        } else {
 379                struct tree_desc trees[2];
 380                struct tree *tree;
 381                struct unpack_trees_options topts;
 382
 383                memset(&topts, 0, sizeof(topts));
 384                topts.head_idx = -1;
 385                topts.src_index = &the_index;
 386                topts.dst_index = &the_index;
 387
 388                topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
 389
 390                refresh_cache(REFRESH_QUIET);
 391
 392                if (unmerged_cache()) {
 393                        error("you need to resolve your current index first");
 394                        return 1;
 395                }
 396
 397                /* 2-way merge to the new branch */
 398                topts.initial_checkout = is_cache_unborn();
 399                topts.update = 1;
 400                topts.merge = 1;
 401                topts.gently = opts->merge;
 402                topts.verbose_update = !opts->quiet;
 403                topts.fn = twoway_merge;
 404                topts.dir = xcalloc(1, sizeof(*topts.dir));
 405                topts.dir->flags |= DIR_SHOW_IGNORED;
 406                topts.dir->exclude_per_dir = ".gitignore";
 407                tree = parse_tree_indirect(old->commit->object.sha1);
 408                init_tree_desc(&trees[0], tree->buffer, tree->size);
 409                tree = parse_tree_indirect(new->commit->object.sha1);
 410                init_tree_desc(&trees[1], tree->buffer, tree->size);
 411
 412                ret = unpack_trees(2, trees, &topts);
 413                if (ret == -1) {
 414                        /*
 415                         * Unpack couldn't do a trivial merge; either
 416                         * give up or do a real merge, depending on
 417                         * whether the merge flag was used.
 418                         */
 419                        struct tree *result;
 420                        struct tree *work;
 421                        struct merge_options o;
 422                        if (!opts->merge)
 423                                return 1;
 424                        parse_commit(old->commit);
 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.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 update_refs_for_switch(struct checkout_opts *opts,
 479                                   struct branch_info *old,
 480                                   struct branch_info *new)
 481{
 482        struct strbuf msg = STRBUF_INIT;
 483        const char *old_desc;
 484        if (opts->new_branch) {
 485                create_branch(old->name, opts->new_branch, new->name, 0,
 486                              opts->new_branch_log, opts->track);
 487                new->name = opts->new_branch;
 488                setup_branch_path(new);
 489        }
 490
 491        old_desc = old->name;
 492        if (!old_desc && old->commit)
 493                old_desc = sha1_to_hex(old->commit->object.sha1);
 494        strbuf_addf(&msg, "checkout: moving from %s to %s",
 495                    old_desc ? old_desc : "(invalid)", new->name);
 496
 497        if (new->path) {
 498                create_symref("HEAD", new->path, msg.buf);
 499                if (!opts->quiet) {
 500                        if (old->path && !strcmp(new->path, old->path))
 501                                fprintf(stderr, "Already on \"%s\"\n",
 502                                        new->name);
 503                        else
 504                                fprintf(stderr, "Switched to%s branch \"%s\"\n",
 505                                        opts->new_branch ? " a new" : "",
 506                                        new->name);
 507                }
 508        } else if (strcmp(new->name, "HEAD")) {
 509                update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 510                           REF_NODEREF, DIE_ON_ERR);
 511                if (!opts->quiet) {
 512                        if (old->path)
 513                                fprintf(stderr, "Note: moving to \"%s\" which isn't a local branch\nIf you want to create a new branch from this checkout, you may do so\n(now or later) by using -b with the checkout command again. Example:\n  git checkout -b <new_branch_name>\n", new->name);
 514                        describe_detached_head("HEAD is now at", new->commit);
 515                }
 516        }
 517        remove_branch_state();
 518        strbuf_release(&msg);
 519        if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
 520                report_tracking(new);
 521}
 522
 523static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 524{
 525        int ret = 0;
 526        struct branch_info old;
 527        unsigned char rev[20];
 528        int flag;
 529        memset(&old, 0, sizeof(old));
 530        old.path = resolve_ref("HEAD", rev, 0, &flag);
 531        old.commit = lookup_commit_reference_gently(rev, 1);
 532        if (!(flag & REF_ISSYMREF))
 533                old.path = NULL;
 534
 535        if (old.path && !prefixcmp(old.path, "refs/heads/"))
 536                old.name = old.path + strlen("refs/heads/");
 537
 538        if (!new->name) {
 539                new->name = "HEAD";
 540                new->commit = old.commit;
 541                if (!new->commit)
 542                        die("You are on a branch yet to be born");
 543                parse_commit(new->commit);
 544        }
 545
 546        /*
 547         * If we were on a detached HEAD, but we are now moving to
 548         * a new commit, we want to mention the old commit once more
 549         * to remind the user that it might be lost.
 550         */
 551        if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 552                describe_detached_head("Previous HEAD position was", old.commit);
 553
 554        if (!old.commit && !opts->force) {
 555                if (!opts->quiet) {
 556                        warning("You appear to be on a branch yet to be born.");
 557                        warning("Forcing checkout of %s.", new->name);
 558                }
 559                opts->force = 1;
 560        }
 561
 562        ret = merge_working_tree(opts, &old, new);
 563        if (ret)
 564                return ret;
 565
 566        update_refs_for_switch(opts, &old, new);
 567
 568        ret = post_checkout_hook(old.commit, new->commit, 1);
 569        return ret || opts->writeout_error;
 570}
 571
 572static int git_checkout_config(const char *var, const char *value, void *cb)
 573{
 574        return git_xmerge_config(var, value, cb);
 575}
 576
 577int cmd_checkout(int argc, const char **argv, const char *prefix)
 578{
 579        struct checkout_opts opts;
 580        unsigned char rev[20];
 581        const char *arg;
 582        struct branch_info new;
 583        struct tree *source_tree = NULL;
 584        char *conflict_style = NULL;
 585        struct option options[] = {
 586                OPT__QUIET(&opts.quiet),
 587                OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
 588                OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
 589                OPT_SET_INT('t', "track",  &opts.track, "track",
 590                        BRANCH_TRACK_EXPLICIT),
 591                OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
 592                            2),
 593                OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
 594                            3),
 595                OPT_BOOLEAN('f', NULL, &opts.force, "force"),
 596                OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
 597                OPT_STRING(0, "conflict", &conflict_style, "style",
 598                           "conflict style (merge or diff3)"),
 599                OPT_END(),
 600        };
 601        int has_dash_dash;
 602
 603        memset(&opts, 0, sizeof(opts));
 604        memset(&new, 0, sizeof(new));
 605
 606        git_config(git_checkout_config, NULL);
 607
 608        opts.track = BRANCH_TRACK_UNSPECIFIED;
 609
 610        argc = parse_options(argc, argv, options, checkout_usage,
 611                             PARSE_OPT_KEEP_DASHDASH);
 612
 613        /* --track without -b should DWIM */
 614        if (0 < opts.track && !opts.new_branch) {
 615                const char *argv0 = argv[0];
 616                if (!argc || !strcmp(argv0, "--"))
 617                        die ("--track needs a branch name");
 618                if (!prefixcmp(argv0, "refs/"))
 619                        argv0 += 5;
 620                if (!prefixcmp(argv0, "remotes/"))
 621                        argv0 += 8;
 622                argv0 = strchr(argv0, '/');
 623                if (!argv0 || !argv0[1])
 624                        die ("Missing branch name; try -b");
 625                opts.new_branch = argv0 + 1;
 626        }
 627
 628        if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 629                opts.track = git_branch_track;
 630        if (conflict_style) {
 631                opts.merge = 1; /* implied */
 632                git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 633        }
 634
 635        if (opts.force && opts.merge)
 636                die("git checkout: -f and -m are incompatible");
 637
 638        /*
 639         * case 1: git checkout <ref> -- [<paths>]
 640         *
 641         *   <ref> must be a valid tree, everything after the '--' must be
 642         *   a path.
 643         *
 644         * case 2: git checkout -- [<paths>]
 645         *
 646         *   everything after the '--' must be paths.
 647         *
 648         * case 3: git checkout <something> [<paths>]
 649         *
 650         *   With no paths, if <something> is a commit, that is to
 651         *   switch to the branch or detach HEAD at it.
 652         *
 653         *   Otherwise <something> shall not be ambiguous.
 654         *   - If it's *only* a reference, treat it like case (1).
 655         *   - If it's only a path, treat it like case (2).
 656         *   - else: fail.
 657         *
 658         */
 659        if (argc) {
 660                if (!strcmp(argv[0], "--")) {       /* case (2) */
 661                        argv++;
 662                        argc--;
 663                        goto no_reference;
 664                }
 665
 666                arg = argv[0];
 667                has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 668
 669                if (!strcmp(arg, "-"))
 670                        arg = "@{-1}";
 671
 672                if (get_sha1(arg, rev)) {
 673                        if (has_dash_dash)          /* case (1) */
 674                                die("invalid reference: %s", arg);
 675                        goto no_reference;          /* case (3 -> 2) */
 676                }
 677
 678                /* we can't end up being in (2) anymore, eat the argument */
 679                argv++;
 680                argc--;
 681
 682                new.name = arg;
 683                if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 684                        setup_branch_path(&new);
 685                        if (resolve_ref(new.path, rev, 1, NULL))
 686                                new.commit = lookup_commit_reference(rev);
 687                        else
 688                                new.path = NULL;
 689                        parse_commit(new.commit);
 690                        source_tree = new.commit->tree;
 691                } else
 692                        source_tree = parse_tree_indirect(rev);
 693
 694                if (!source_tree)                   /* case (1): want a tree */
 695                        die("reference is not a tree: %s", arg);
 696                if (!has_dash_dash) {/* case (3 -> 1) */
 697                        /*
 698                         * Do not complain the most common case
 699                         *      git checkout branch
 700                         * even if there happen to be a file called 'branch';
 701                         * it would be extremely annoying.
 702                         */
 703                        if (argc)
 704                                verify_non_filename(NULL, arg);
 705                }
 706                else {
 707                        argv++;
 708                        argc--;
 709                }
 710        }
 711
 712no_reference:
 713        if (argc) {
 714                const char **pathspec = get_pathspec(prefix, argv);
 715
 716                if (!pathspec)
 717                        die("invalid path specification");
 718
 719                /* Checkout paths */
 720                if (opts.new_branch) {
 721                        if (argc == 1) {
 722                                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]);
 723                        } else {
 724                                die("git checkout: updating paths is incompatible with switching branches.");
 725                        }
 726                }
 727
 728                if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 729                        die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 730
 731                return checkout_paths(source_tree, pathspec, &opts);
 732        }
 733
 734        if (opts.new_branch) {
 735                struct strbuf buf = STRBUF_INIT;
 736                if (strbuf_check_branch_ref(&buf, opts.new_branch))
 737                        die("git checkout: we do not like '%s' as a branch name.",
 738                            opts.new_branch);
 739                if (!get_sha1(buf.buf, rev))
 740                        die("git checkout: branch %s already exists", opts.new_branch);
 741                strbuf_release(&buf);
 742        }
 743
 744        if (new.name && !new.commit) {
 745                die("Cannot switch branch to a non-commit.");
 746        }
 747        if (opts.writeout_stage)
 748                die("--ours/--theirs is incompatible with switching branches.");
 749
 750        return switch_branches(&opts, &new);
 751}