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
  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                 "If you want to keep them by creating a new branch, "
 639                 "this may be a good time\nto do so with:\n\n"
 640                 " git branch new_branch_name %s\n\n",
 641                 lost, ((1 < lost) ? "s" : ""),
 642                 sb.buf,
 643                 sha1_to_hex(commit->object.sha1));
 644         strbuf_release(&sb);
 645 }
 646
 647 /*
 648  * We are about to leave commit that was at the tip of a detached
 649  * HEAD.  If it is not reachable from any ref, this is the last chance
 650  * for the user to do so without resorting to reflog.
 651  */
 652 static void orphaned_commit_warning(struct commit *commit)
 653 {
 654         struct rev_list_args args = { 0, 0, NULL };
 655         struct rev_info revs;
 656
 657         add_one_rev_list_arg(&args, "(internal)");
 658         add_one_rev_list_arg(&args, sha1_to_hex(commit->object.sha1));
 659         add_one_rev_list_arg(&args, "--not");
 660         for_each_ref(add_one_ref_to_rev_list_arg, &args);
 661         add_one_rev_list_arg(&args, "--");
 662         add_one_rev_list_arg(&args, NULL);
 663
 664         init_revisions(&revs, NULL);
 665         if (setup_revisions(args.argc - 1, args.argv, &revs, NULL) != 1)
 666                 die("internal error: only -- alone should have been left");
 667         if (prepare_revision_walk(&revs))
 668                 die("internal error in revision walk");
 669         if (!(commit->object.flags & UNINTERESTING))
 670                 suggest_reattach(commit, &revs);
 671         else
 672                 describe_detached_head("Previous HEAD position was", commit);
 673 }
 674
 675 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 676 {
 677         int ret = 0;
 678         struct branch_info old;
 679         unsigned char rev[20];
 680         int flag;
 681         memset(&old, 0, sizeof(old));
 682         old.path = resolve_ref("HEAD", rev, 0, &flag);
 683         old.commit = lookup_commit_reference_gently(rev, 1);
 684         if (!(flag & REF_ISSYMREF))
 685                 old.path = NULL;
 686
 687         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 688                 old.name = old.path + strlen("refs/heads/");
 689
 690         if (!new->name) {
 691                 new->name = "HEAD";
 692                 new->commit = old.commit;
 693                 if (!new->commit)
 694                         die("You are on a branch yet to be born");
 695                 parse_commit(new->commit);
 696         }
 697
 698         ret = merge_working_tree(opts, &old, new);
 699         if (ret)
 700                 return ret;
 701
 702         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 703                 orphaned_commit_warning(old.commit);
 704
 705         update_refs_for_switch(opts, &old, new);
 706
 707         ret = post_checkout_hook(old.commit, new->commit, 1);
 708         return ret || opts->writeout_error;
 709 }
 710
 711 static int git_checkout_config(const char *var, const char *value, void *cb)
 712 {
 713         if (!strcmp(var, "diff.ignoresubmodules")) {
 714                 struct checkout_opts *opts = cb;
 715                 handle_ignore_submodules_arg(&opts->diff_options, value);
 716                 return 0;
 717         }
 718
 719         if (!prefixcmp(var, "submodule."))
 720                 return parse_submodule_config_option(var, value);
 721
 722         return git_xmerge_config(var, value, NULL);
 723 }
 724
 725 static int interactive_checkout(const char *revision, const char **pathspec,
 726                                 struct checkout_opts *opts)
 727 {
 728         return run_add_interactive(revision, "--patch=checkout", pathspec);
 729 }
 730
 731 struct tracking_name_data {
 732         const char *name;
 733         char *remote;
 734         int unique;
 735 };
 736
 737 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 738                                int flags, void *cb_data)
 739 {
 740         struct tracking_name_data *cb = cb_data;
 741         const char *slash;
 742
 743         if (prefixcmp(refname, "refs/remotes/"))
 744                 return 0;
 745         slash = strchr(refname + 13, '/');
 746         if (!slash || strcmp(slash + 1, cb->name))
 747                 return 0;
 748         if (cb->remote) {
 749                 cb->unique = 0;
 750                 return 0;
 751         }
 752         cb->remote = xstrdup(refname);
 753         return 0;
 754 }
 755
 756 static const char *unique_tracking_name(const char *name)
 757 {
 758         struct tracking_name_data cb_data = { NULL, NULL, 1 };
 759         cb_data.name = name;
 760         for_each_ref(check_tracking_name, &cb_data);
 761         if (cb_data.unique)
 762                 return cb_data.remote;
 763         free(cb_data.remote);
 764         return NULL;
 765 }
 766
 767 int cmd_checkout(int argc, const char **argv, const char *prefix)
 768 {
 769         struct checkout_opts opts;
 770         unsigned char rev[20];
 771         const char *arg;
 772         struct branch_info new;
 773         struct tree *source_tree = NULL;
 774         char *conflict_style = NULL;
 775         int patch_mode = 0;
 776         int dwim_new_local_branch = 1;
 777         struct option options[] = {
 778                 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
 779                 OPT_STRING('b', NULL, &opts.new_branch, "branch",
 780                            "create and checkout a new branch"),
 781                 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 782                            "create/reset and checkout a branch"),
 783                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
 784                 OPT_SET_INT('t', "track",  &opts.track, "set upstream info for new branch",
 785                         BRANCH_TRACK_EXPLICIT),
 786                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 787                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
 788                             2),
 789                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
 790                             3),
 791                 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
 792                 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
 793                 OPT_STRING(0, "conflict", &conflict_style, "style",
 794                            "conflict style (merge or diff3)"),
 795                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 796                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 797                   "second guess 'git checkout no-such-branch'",
 798                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 799                 OPT_END(),
 800         };
 801         int has_dash_dash;
 802
 803         memset(&opts, 0, sizeof(opts));
 804         memset(&new, 0, sizeof(new));
 805
 806         gitmodules_config();
 807         git_config(git_checkout_config, &opts);
 808
 809         opts.track = BRANCH_TRACK_UNSPECIFIED;
 810
 811         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 812                              PARSE_OPT_KEEP_DASHDASH);
 813
 814         /* we can assume from now on new_branch = !new_branch_force */
 815         if (opts.new_branch && opts.new_branch_force)
 816                 die("-B cannot be used with -b");
 817
 818         /* copy -B over to -b, so that we can just check the latter */
 819         if (opts.new_branch_force)
 820                 opts.new_branch = opts.new_branch_force;
 821
 822         if (patch_mode && (opts.track > 0 || opts.new_branch
 823                            || opts.new_branch_log || opts.merge || opts.force))
 824                 die ("--patch is incompatible with all other options");
 825
 826         /* --track without -b should DWIM */
 827         if (0 < opts.track && !opts.new_branch) {
 828                 const char *argv0 = argv[0];
 829                 if (!argc || !strcmp(argv0, "--"))
 830                         die ("--track needs a branch name");
 831                 if (!prefixcmp(argv0, "refs/"))
 832                         argv0 += 5;
 833                 if (!prefixcmp(argv0, "remotes/"))
 834                         argv0 += 8;
 835                 argv0 = strchr(argv0, '/');
 836                 if (!argv0 || !argv0[1])
 837                         die ("Missing branch name; try -b");
 838                 opts.new_branch = argv0 + 1;
 839         }
 840
 841         if (opts.new_orphan_branch) {
 842                 if (opts.new_branch)
 843                         die("--orphan and -b|-B are mutually exclusive");
 844                 if (opts.track > 0)
 845                         die("--orphan cannot be used with -t");
 846                 opts.new_branch = opts.new_orphan_branch;
 847         }
 848
 849         if (conflict_style) {
 850                 opts.merge = 1; /* implied */
 851                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 852         }
 853
 854         if (opts.force && opts.merge)
 855                 die("git checkout: -f and -m are incompatible");
 856
 857         /*
 858          * case 1: git checkout <ref> -- [<paths>]
 859          *
 860          *   <ref> must be a valid tree, everything after the '--' must be
 861          *   a path.
 862          *
 863          * case 2: git checkout -- [<paths>]
 864          *
 865          *   everything after the '--' must be paths.
 866          *
 867          * case 3: git checkout <something> [<paths>]
 868          *
 869          *   With no paths, if <something> is a commit, that is to
 870          *   switch to the branch or detach HEAD at it.  As a special case,
 871          *   if <something> is A...B (missing A or B means HEAD but you can
 872          *   omit at most one side), and if there is a unique merge base
 873          *   between A and B, A...B names that merge base.
 874          *
 875          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 876          *   was given, and there is a remote-tracking branch whose name is
 877          *   <something> in one and only one remote, then this is a short-hand
 878          *   to fork local <something> from that remote-tracking branch.
 879          *
 880          *   Otherwise <something> shall not be ambiguous.
 881          *   - If it's *only* a reference, treat it like case (1).
 882          *   - If it's only a path, treat it like case (2).
 883          *   - else: fail.
 884          *
 885          */
 886         if (argc) {
 887                 if (!strcmp(argv[0], "--")) {       /* case (2) */
 888                         argv++;
 889                         argc--;
 890                         goto no_reference;
 891                 }
 892
 893                 arg = argv[0];
 894                 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 895
 896                 if (!strcmp(arg, "-"))
 897                         arg = "@{-1}";
 898
 899                 if (get_sha1_mb(arg, rev)) {
 900                         if (has_dash_dash)          /* case (1) */
 901                                 die("invalid reference: %s", arg);
 902                         if (!patch_mode &&
 903                             dwim_new_local_branch &&
 904                             opts.track == BRANCH_TRACK_UNSPECIFIED &&
 905                             !opts.new_branch &&
 906                             !check_filename(NULL, arg) &&
 907                             argc == 1) {
 908                                 const char *remote = unique_tracking_name(arg);
 909                                 if (!remote || get_sha1(remote, rev))
 910                                         goto no_reference;
 911                                 opts.new_branch = arg;
 912                                 arg = remote;
 913                                 /* DWIMmed to create local branch */
 914                         }
 915                         else
 916                                 goto no_reference;
 917                 }
 918
 919                 /* we can't end up being in (2) anymore, eat the argument */
 920                 argv++;
 921                 argc--;
 922
 923                 new.name = arg;
 924                 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
 925                         setup_branch_path(&new);
 926
 927                         if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
 928                             resolve_ref(new.path, rev, 1, NULL))
 929                                 ;
 930                         else
 931                                 new.path = NULL;
 932                         parse_commit(new.commit);
 933                         source_tree = new.commit->tree;
 934                 } else
 935                         source_tree = parse_tree_indirect(rev);
 936
 937                 if (!source_tree)                   /* case (1): want a tree */
 938                         die("reference is not a tree: %s", arg);
 939                 if (!has_dash_dash) {/* case (3 -> 1) */
 940                         /*
 941                          * Do not complain the most common case
 942                          *      git checkout branch
 943                          * even if there happen to be a file called 'branch';
 944                          * it would be extremely annoying.
 945                          */
 946                         if (argc)
 947                                 verify_non_filename(NULL, arg);
 948                 }
 949                 else {
 950                         argv++;
 951                         argc--;
 952                 }
 953         }
 954
 955 no_reference:
 956
 957         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
 958                 opts.track = git_branch_track;
 959
 960         if (argc) {
 961                 const char **pathspec = get_pathspec(prefix, argv);
 962
 963                 if (!pathspec)
 964                         die("invalid path specification");
 965
 966                 if (patch_mode)
 967                         return interactive_checkout(new.name, pathspec, &opts);
 968
 969                 /* Checkout paths */
 970                 if (opts.new_branch) {
 971                         if (argc == 1) {
 972                                 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]);
 973                         } else {
 974                                 die("git checkout: updating paths is incompatible with switching branches.");
 975                         }
 976                 }
 977
 978                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
 979                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
 980
 981                 return checkout_paths(source_tree, pathspec, &opts);
 982         }
 983
 984         if (patch_mode)
 985                 return interactive_checkout(new.name, NULL, &opts);
 986
 987         if (opts.new_branch) {
 988                 struct strbuf buf = STRBUF_INIT;
 989                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
 990                         die("git checkout: we do not like '%s' as a branch name.",
 991                             opts.new_branch);
 992                 if (!get_sha1(buf.buf, rev)) {
 993                         opts.branch_exists = 1;
 994                         if (!opts.new_branch_force)
 995                                 die("git checkout: branch %s already exists",
 996                                     opts.new_branch);
 997                 }
 998                 strbuf_release(&buf);
 999         }
1000
1001         if (new.name && !new.commit) {
1002                 die("Cannot switch branch to a non-commit.");
1003         }
1004         if (opts.writeout_stage)
1005                 die("--ours/--theirs is incompatible with switching branches.");
1006
1007         return switch_branches(&opts, &new);
1008 }