builtin/checkout.c

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