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