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