git.oblomov.eu Git - git/blob - builtin/checkout.c

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