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