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