3 #include "parse-options.h"
8 #include "cache-tree.h"
9 #include "unpack-trees.h"
11 #include "run-command.h"
12 #include "merge-recursive.h"
18 #include "xdiff-interface.h"
20 #include "resolve-undo.h"
22 static const char * const checkout_usage[] = {
23 "git checkout [options] <branch>",
24 "git checkout [options] [<branch>] -- <file>...",
28 struct checkout_opts {
35 const char *new_branch;
36 const char *new_orphan_branch;
38 enum branch_track track;
41 static int post_checkout_hook(struct commit *old, struct commit *new,
44 return run_hook(NULL, "post-checkout",
45 sha1_to_hex(old ? old->object.sha1 : null_sha1),
46 sha1_to_hex(new ? new->object.sha1 : null_sha1),
47 changed ? "1" : "0", NULL);
48 /* "new" can be NULL when checking out from the index before
53 static int update_some(const unsigned char *sha1, const char *base, int baselen,
54 const char *pathname, unsigned mode, int stage, void *context)
57 struct cache_entry *ce;
60 return READ_TREE_RECURSIVE;
62 len = baselen + strlen(pathname);
63 ce = xcalloc(1, cache_entry_size(len));
64 hashcpy(ce->sha1, sha1);
65 memcpy(ce->name, base, baselen);
66 memcpy(ce->name + baselen, pathname, len - baselen);
67 ce->ce_flags = create_ce_flags(len, 0);
68 ce->ce_mode = create_ce_mode(mode);
69 add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
73 static int read_tree_some(struct tree *tree, const char **pathspec)
75 read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
77 /* update the index with the given tree's info
78 * for all args, expanding wildcards, and exit
79 * with any non-zero return code.
84 static int skip_same_name(struct cache_entry *ce, int pos)
86 while (++pos < active_nr &&
87 !strcmp(active_cache[pos]->name, ce->name))
92 static int check_stage(int stage, struct cache_entry *ce, int pos)
94 while (pos < active_nr &&
95 !strcmp(active_cache[pos]->name, ce->name)) {
96 if (ce_stage(active_cache[pos]) == stage)
100 return error("path '%s' does not have %s version",
102 (stage == 2) ? "our" : "their");
105 static int check_all_stages(struct cache_entry *ce, int pos)
107 if (ce_stage(ce) != 1 ||
108 active_nr <= pos + 2 ||
109 strcmp(active_cache[pos+1]->name, ce->name) ||
110 ce_stage(active_cache[pos+1]) != 2 ||
111 strcmp(active_cache[pos+2]->name, ce->name) ||
112 ce_stage(active_cache[pos+2]) != 3)
113 return error("path '%s' does not have all three versions",
118 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
119 struct checkout *state)
121 while (pos < active_nr &&
122 !strcmp(active_cache[pos]->name, ce->name)) {
123 if (ce_stage(active_cache[pos]) == stage)
124 return checkout_entry(active_cache[pos], state, NULL);
127 return error("path '%s' does not have %s version",
129 (stage == 2) ? "our" : "their");
132 static int checkout_merged(int pos, struct checkout *state)
134 struct cache_entry *ce = active_cache[pos];
135 const char *path = ce->name;
136 mmfile_t ancestor, ours, theirs;
138 unsigned char sha1[20];
139 mmbuffer_t result_buf;
141 if (ce_stage(ce) != 1 ||
142 active_nr <= pos + 2 ||
143 strcmp(active_cache[pos+1]->name, path) ||
144 ce_stage(active_cache[pos+1]) != 2 ||
145 strcmp(active_cache[pos+2]->name, path) ||
146 ce_stage(active_cache[pos+2]) != 3)
147 return error("path '%s' does not have all 3 versions", path);
149 read_mmblob(&ancestor, active_cache[pos]->sha1);
150 read_mmblob(&ours, active_cache[pos+1]->sha1);
151 read_mmblob(&theirs, active_cache[pos+2]->sha1);
153 status = ll_merge(&result_buf, path, &ancestor, "base",
154 &ours, "ours", &theirs, "theirs", 0);
158 if (status < 0 || !result_buf.ptr) {
159 free(result_buf.ptr);
160 return error("path '%s': cannot merge", path);
165 * There is absolutely no reason to write this as a blob object
166 * and create a phony cache entry just to leak. This hack is
167 * primarily to get to the write_entry() machinery that massages
168 * the contents to work-tree format and writes out which only
169 * allows it for a cache entry. The code in write_entry() needs
170 * to be refactored to allow us to feed a <buffer, size, mode>
171 * instead of a cache entry. Such a refactoring would help
172 * merge_recursive as well (it also writes the merge result to the
173 * object database even when it may contain conflicts).
175 if (write_sha1_file(result_buf.ptr, result_buf.size,
177 die("Unable to add merge result for '%s'", path);
178 ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
182 die("make_cache_entry failed for path '%s'", path);
183 status = checkout_entry(ce, state, NULL);
187 static int checkout_paths(struct tree *source_tree, const char **pathspec,
188 struct checkout_opts *opts)
191 struct checkout state;
192 static char *ps_matched;
193 unsigned char rev[20];
197 int stage = opts->writeout_stage;
198 int merge = opts->merge;
200 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
202 newfd = hold_locked_index(lock_file, 1);
203 if (read_cache_preload(pathspec) < 0)
204 return error("corrupt index file");
207 read_tree_some(source_tree, pathspec);
209 for (pos = 0; pathspec[pos]; pos++)
211 ps_matched = xcalloc(1, pos);
213 for (pos = 0; pos < active_nr; pos++) {
214 struct cache_entry *ce = active_cache[pos];
215 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
218 if (report_path_error(ps_matched, pathspec, 0))
221 /* "checkout -m path" to recreate conflicted state */
223 unmerge_cache(pathspec);
225 /* Any unmerged paths? */
226 for (pos = 0; pos < active_nr; pos++) {
227 struct cache_entry *ce = active_cache[pos];
228 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
232 warning("path '%s' is unmerged", ce->name);
234 errs |= check_stage(stage, ce, pos);
235 } else if (opts->merge) {
236 errs |= check_all_stages(ce, pos);
239 error("path '%s' is unmerged", ce->name);
241 pos = skip_same_name(ce, pos) - 1;
247 /* Now we are committed to check them out */
248 memset(&state, 0, sizeof(state));
250 state.refresh_cache = 1;
251 for (pos = 0; pos < active_nr; pos++) {
252 struct cache_entry *ce = active_cache[pos];
253 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
255 errs |= checkout_entry(ce, &state, NULL);
259 errs |= checkout_stage(stage, ce, pos, &state);
261 errs |= checkout_merged(pos, &state);
262 pos = skip_same_name(ce, pos) - 1;
266 if (write_cache(newfd, active_cache, active_nr) ||
267 commit_locked_index(lock_file))
268 die("unable to write new index file");
270 resolve_ref("HEAD", rev, 0, &flag);
271 head = lookup_commit_reference_gently(rev, 1);
273 errs |= post_checkout_hook(head, head, 0);
277 static void show_local_changes(struct object *head)
280 /* I think we want full paths, even if we're in a subdirectory. */
281 init_revisions(&rev, NULL);
283 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
284 if (diff_setup_done(&rev.diffopt) < 0)
285 die("diff_setup_done failed");
286 add_pending_object(&rev, head, NULL);
287 run_diff_index(&rev, 0);
290 static void describe_detached_head(char *msg, struct commit *commit)
292 struct strbuf sb = STRBUF_INIT;
293 struct pretty_print_context ctx = {0};
294 parse_commit(commit);
295 pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
296 fprintf(stderr, "%s %s... %s\n", msg,
297 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
301 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
303 struct unpack_trees_options opts;
304 struct tree_desc tree_desc;
306 memset(&opts, 0, sizeof(opts));
308 opts.update = worktree;
309 opts.skip_unmerged = !worktree;
312 opts.fn = oneway_merge;
313 opts.verbose_update = !o->quiet;
314 opts.src_index = &the_index;
315 opts.dst_index = &the_index;
317 init_tree_desc(&tree_desc, tree->buffer, tree->size);
318 switch (unpack_trees(1, &tree_desc, &opts)) {
320 o->writeout_error = 1;
322 * We return 0 nevertheless, as the index is all right
323 * and more importantly we have made best efforts to
324 * update paths in the work tree, and we cannot revert
335 const char *name; /* The short name used */
336 const char *path; /* The full name of a real branch */
337 struct commit *commit; /* The named commit */
340 static void setup_branch_path(struct branch_info *branch)
342 struct strbuf buf = STRBUF_INIT;
344 strbuf_branchname(&buf, branch->name);
345 if (strcmp(buf.buf, branch->name))
346 branch->name = xstrdup(buf.buf);
347 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
348 branch->path = strbuf_detach(&buf, NULL);
351 static int merge_working_tree(struct checkout_opts *opts,
352 struct branch_info *old, struct branch_info *new)
355 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
356 int newfd = hold_locked_index(lock_file, 1);
358 if (read_cache_preload(NULL) < 0)
359 return error("corrupt index file");
361 resolve_undo_clear();
363 ret = reset_tree(new->commit->tree, opts, 1);
367 struct tree_desc trees[2];
369 struct unpack_trees_options topts;
371 memset(&topts, 0, sizeof(topts));
373 topts.src_index = &the_index;
374 topts.dst_index = &the_index;
376 topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
378 refresh_cache(REFRESH_QUIET);
380 if (unmerged_cache()) {
381 error("you need to resolve your current index first");
385 /* 2-way merge to the new branch */
386 topts.initial_checkout = is_cache_unborn();
389 topts.gently = opts->merge && old->commit;
390 topts.verbose_update = !opts->quiet;
391 topts.fn = twoway_merge;
392 topts.dir = xcalloc(1, sizeof(*topts.dir));
393 topts.dir->flags |= DIR_SHOW_IGNORED;
394 topts.dir->exclude_per_dir = ".gitignore";
395 tree = parse_tree_indirect(old->commit ?
396 old->commit->object.sha1 :
397 (unsigned char *)EMPTY_TREE_SHA1_BIN);
398 init_tree_desc(&trees[0], tree->buffer, tree->size);
399 tree = parse_tree_indirect(new->commit->object.sha1);
400 init_tree_desc(&trees[1], tree->buffer, tree->size);
402 ret = unpack_trees(2, trees, &topts);
405 * Unpack couldn't do a trivial merge; either
406 * give up or do a real merge, depending on
407 * whether the merge flag was used.
411 struct merge_options o;
416 * Without old->commit, the below is the same as
417 * the two-tree unpack we already tried and failed.
422 /* Do more real merge */
425 * We update the index fully, then write the
426 * tree from the index, then merge the new
427 * branch with the current tree, with the old
428 * branch as the base. Then we reset the index
429 * (but not the working tree) to the new
430 * branch, leaving the working tree as the
431 * merged version, but skipping unmerged
432 * entries in the index.
435 add_files_to_cache(NULL, NULL, 0);
436 init_merge_options(&o);
438 work = write_tree_from_memory(&o);
440 ret = reset_tree(new->commit->tree, opts, 1);
443 o.ancestor = old->name;
444 o.branch1 = new->name;
446 merge_trees(&o, new->commit->tree, work,
447 old->commit->tree, &result);
448 ret = reset_tree(new->commit->tree, opts, 0);
454 if (write_cache(newfd, active_cache, active_nr) ||
455 commit_locked_index(lock_file))
456 die("unable to write new index file");
458 if (!opts->force && !opts->quiet)
459 show_local_changes(&new->commit->object);
464 static void report_tracking(struct branch_info *new)
466 struct strbuf sb = STRBUF_INIT;
467 struct branch *branch = branch_get(new->name);
469 if (!format_tracking_info(branch, &sb))
471 fputs(sb.buf, stdout);
475 static void detach_advice(const char *old_path, const char *new_name)
478 "Note: checking out '%s'.\n\n"
479 "You are in 'detached HEAD' state. You can look around, make experimental\n"
480 "changes and commit them, and you can discard any commits you make in this\n"
481 "state without impacting any branches by performing another checkout.\n\n"
482 "If you want to create a new branch to retain commits you create, you may\n"
483 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
484 " git checkout -b new_branch_name\n\n";
486 fprintf(stderr, fmt, new_name);
489 static void update_refs_for_switch(struct checkout_opts *opts,
490 struct branch_info *old,
491 struct branch_info *new)
493 struct strbuf msg = STRBUF_INIT;
494 const char *old_desc;
495 if (opts->new_branch) {
496 if (opts->new_orphan_branch) {
497 if (opts->new_branch_log && !log_all_ref_updates) {
499 char log_file[PATH_MAX];
500 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
502 temp = log_all_ref_updates;
503 log_all_ref_updates = 1;
504 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
505 fprintf(stderr, "Can not do reflog for '%s'\n",
506 opts->new_orphan_branch);
507 log_all_ref_updates = temp;
510 log_all_ref_updates = temp;
514 create_branch(old->name, opts->new_branch, new->name, 0,
515 opts->new_branch_log, opts->track);
516 new->name = opts->new_branch;
517 setup_branch_path(new);
520 old_desc = old->name;
521 if (!old_desc && old->commit)
522 old_desc = sha1_to_hex(old->commit->object.sha1);
523 strbuf_addf(&msg, "checkout: moving from %s to %s",
524 old_desc ? old_desc : "(invalid)", new->name);
527 create_symref("HEAD", new->path, msg.buf);
529 if (old->path && !strcmp(new->path, old->path))
530 fprintf(stderr, "Already on '%s'\n",
533 fprintf(stderr, "Switched to%s branch '%s'\n",
534 opts->new_branch ? " a new" : "",
537 if (old->path && old->name) {
538 char log_file[PATH_MAX], ref_file[PATH_MAX];
540 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
541 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
542 if (!file_exists(ref_file) && file_exists(log_file))
543 remove_path(log_file);
545 } else if (strcmp(new->name, "HEAD")) {
546 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
547 REF_NODEREF, DIE_ON_ERR);
549 if (old->path && advice_detached_head)
550 detach_advice(old->path, new->name);
551 describe_detached_head("HEAD is now at", new->commit);
554 remove_branch_state();
555 strbuf_release(&msg);
556 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
557 report_tracking(new);
560 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
563 struct branch_info old;
564 unsigned char rev[20];
566 memset(&old, 0, sizeof(old));
567 old.path = resolve_ref("HEAD", rev, 0, &flag);
568 old.commit = lookup_commit_reference_gently(rev, 1);
569 if (!(flag & REF_ISSYMREF))
572 if (old.path && !prefixcmp(old.path, "refs/heads/"))
573 old.name = old.path + strlen("refs/heads/");
577 new->commit = old.commit;
579 die("You are on a branch yet to be born");
580 parse_commit(new->commit);
583 ret = merge_working_tree(opts, &old, new);
588 * If we were on a detached HEAD, but have now moved to
589 * a new commit, we want to mention the old commit once more
590 * to remind the user that it might be lost.
592 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
593 describe_detached_head("Previous HEAD position was", old.commit);
595 update_refs_for_switch(opts, &old, new);
597 ret = post_checkout_hook(old.commit, new->commit, 1);
598 return ret || opts->writeout_error;
601 static int git_checkout_config(const char *var, const char *value, void *cb)
603 return git_xmerge_config(var, value, cb);
606 static int interactive_checkout(const char *revision, const char **pathspec,
607 struct checkout_opts *opts)
609 return run_add_interactive(revision, "--patch=checkout", pathspec);
612 struct tracking_name_data {
618 static int check_tracking_name(const char *refname, const unsigned char *sha1,
619 int flags, void *cb_data)
621 struct tracking_name_data *cb = cb_data;
624 if (prefixcmp(refname, "refs/remotes/"))
626 slash = strchr(refname + 13, '/');
627 if (!slash || strcmp(slash + 1, cb->name))
633 cb->remote = xstrdup(refname);
637 static const char *unique_tracking_name(const char *name)
639 struct tracking_name_data cb_data = { name, NULL, 1 };
640 for_each_ref(check_tracking_name, &cb_data);
642 return cb_data.remote;
643 free(cb_data.remote);
647 int cmd_checkout(int argc, const char **argv, const char *prefix)
649 struct checkout_opts opts;
650 unsigned char rev[20];
652 struct branch_info new;
653 struct tree *source_tree = NULL;
654 char *conflict_style = NULL;
656 int dwim_new_local_branch = 1;
657 struct option options[] = {
658 OPT__QUIET(&opts.quiet),
659 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
660 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
661 OPT_SET_INT('t', "track", &opts.track, "track",
662 BRANCH_TRACK_EXPLICIT),
663 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
664 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
666 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
668 OPT_BOOLEAN('f', "force", &opts.force, "force"),
669 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
670 OPT_STRING(0, "conflict", &conflict_style, "style",
671 "conflict style (merge or diff3)"),
672 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
673 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
674 "second guess 'git checkout no-such-branch'",
675 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
680 memset(&opts, 0, sizeof(opts));
681 memset(&new, 0, sizeof(new));
683 git_config(git_checkout_config, NULL);
685 opts.track = BRANCH_TRACK_UNSPECIFIED;
687 argc = parse_options(argc, argv, prefix, options, checkout_usage,
688 PARSE_OPT_KEEP_DASHDASH);
690 if (patch_mode && (opts.track > 0 || opts.new_branch
691 || opts.new_branch_log || opts.merge || opts.force))
692 die ("--patch is incompatible with all other options");
694 /* --track without -b should DWIM */
695 if (0 < opts.track && !opts.new_branch) {
696 const char *argv0 = argv[0];
697 if (!argc || !strcmp(argv0, "--"))
698 die ("--track needs a branch name");
699 if (!prefixcmp(argv0, "refs/"))
701 if (!prefixcmp(argv0, "remotes/"))
703 argv0 = strchr(argv0, '/');
704 if (!argv0 || !argv0[1])
705 die ("Missing branch name; try -b");
706 opts.new_branch = argv0 + 1;
709 if (opts.new_orphan_branch) {
711 die("--orphan and -b are mutually exclusive");
713 die("--orphan cannot be used with -t");
714 opts.new_branch = opts.new_orphan_branch;
717 if (conflict_style) {
718 opts.merge = 1; /* implied */
719 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
722 if (opts.force && opts.merge)
723 die("git checkout: -f and -m are incompatible");
726 * case 1: git checkout <ref> -- [<paths>]
728 * <ref> must be a valid tree, everything after the '--' must be
731 * case 2: git checkout -- [<paths>]
733 * everything after the '--' must be paths.
735 * case 3: git checkout <something> [<paths>]
737 * With no paths, if <something> is a commit, that is to
738 * switch to the branch or detach HEAD at it. As a special case,
739 * if <something> is A...B (missing A or B means HEAD but you can
740 * omit at most one side), and if there is a unique merge base
741 * between A and B, A...B names that merge base.
743 * With no paths, if <something> is _not_ a commit, no -t nor -b
744 * was given, and there is a tracking branch whose name is
745 * <something> in one and only one remote, then this is a short-hand
746 * to fork local <something> from that remote tracking branch.
748 * Otherwise <something> shall not be ambiguous.
749 * - If it's *only* a reference, treat it like case (1).
750 * - If it's only a path, treat it like case (2).
755 if (!strcmp(argv[0], "--")) { /* case (2) */
762 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
764 if (!strcmp(arg, "-"))
767 if (get_sha1_mb(arg, rev)) {
768 if (has_dash_dash) /* case (1) */
769 die("invalid reference: %s", arg);
771 dwim_new_local_branch &&
772 opts.track == BRANCH_TRACK_UNSPECIFIED &&
774 !check_filename(NULL, arg) &&
776 const char *remote = unique_tracking_name(arg);
777 if (!remote || get_sha1(remote, rev))
779 opts.new_branch = arg;
781 /* DWIMmed to create local branch */
787 /* we can't end up being in (2) anymore, eat the argument */
792 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
793 setup_branch_path(&new);
795 if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
796 resolve_ref(new.path, rev, 1, NULL))
800 parse_commit(new.commit);
801 source_tree = new.commit->tree;
803 source_tree = parse_tree_indirect(rev);
805 if (!source_tree) /* case (1): want a tree */
806 die("reference is not a tree: %s", arg);
807 if (!has_dash_dash) {/* case (3 -> 1) */
809 * Do not complain the most common case
810 * git checkout branch
811 * even if there happen to be a file called 'branch';
812 * it would be extremely annoying.
815 verify_non_filename(NULL, arg);
825 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
826 opts.track = git_branch_track;
829 const char **pathspec = get_pathspec(prefix, argv);
832 die("invalid path specification");
835 return interactive_checkout(new.name, pathspec, &opts);
838 if (opts.new_branch) {
840 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]);
842 die("git checkout: updating paths is incompatible with switching branches.");
846 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
847 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
849 return checkout_paths(source_tree, pathspec, &opts);
853 return interactive_checkout(new.name, NULL, &opts);
855 if (opts.new_branch) {
856 struct strbuf buf = STRBUF_INIT;
857 if (strbuf_check_branch_ref(&buf, opts.new_branch))
858 die("git checkout: we do not like '%s' as a branch name.",
860 if (!get_sha1(buf.buf, rev))
861 die("git checkout: branch %s already exists", opts.new_branch);
862 strbuf_release(&buf);
865 if (new.name && !new.commit) {
866 die("Cannot switch branch to a non-commit.");
868 if (opts.writeout_stage)
869 die("--ours/--theirs is incompatible with switching branches.");
871 return switch_branches(&opts, &new);