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