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