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