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