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