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