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);
154 * NEEDSWORK: re-create conflicts from merges with
155 * merge.renormalize set, too
157 status = ll_merge(&result_buf, path, &ancestor, "base",
158 &ours, "ours", &theirs, "theirs", 0);
162 if (status < 0 || !result_buf.ptr) {
163 free(result_buf.ptr);
164 return error("path '%s': cannot merge", path);
169 * There is absolutely no reason to write this as a blob object
170 * and create a phony cache entry just to leak. This hack is
171 * primarily to get to the write_entry() machinery that massages
172 * the contents to work-tree format and writes out which only
173 * allows it for a cache entry. The code in write_entry() needs
174 * to be refactored to allow us to feed a <buffer, size, mode>
175 * instead of a cache entry. Such a refactoring would help
176 * merge_recursive as well (it also writes the merge result to the
177 * object database even when it may contain conflicts).
179 if (write_sha1_file(result_buf.ptr, result_buf.size,
181 die("Unable to add merge result for '%s'", path);
182 ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
186 die("make_cache_entry failed for path '%s'", path);
187 status = checkout_entry(ce, state, NULL);
191 static int checkout_paths(struct tree *source_tree, const char **pathspec,
192 struct checkout_opts *opts)
195 struct checkout state;
196 static char *ps_matched;
197 unsigned char rev[20];
201 int stage = opts->writeout_stage;
202 int merge = opts->merge;
204 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
206 newfd = hold_locked_index(lock_file, 1);
207 if (read_cache_preload(pathspec) < 0)
208 return error("corrupt index file");
211 read_tree_some(source_tree, pathspec);
213 for (pos = 0; pathspec[pos]; pos++)
215 ps_matched = xcalloc(1, pos);
217 for (pos = 0; pos < active_nr; pos++) {
218 struct cache_entry *ce = active_cache[pos];
219 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
222 if (report_path_error(ps_matched, pathspec, 0))
225 /* "checkout -m path" to recreate conflicted state */
227 unmerge_cache(pathspec);
229 /* Any unmerged paths? */
230 for (pos = 0; pos < active_nr; pos++) {
231 struct cache_entry *ce = active_cache[pos];
232 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
236 warning("path '%s' is unmerged", ce->name);
238 errs |= check_stage(stage, ce, pos);
239 } else if (opts->merge) {
240 errs |= check_all_stages(ce, pos);
243 error("path '%s' is unmerged", ce->name);
245 pos = skip_same_name(ce, pos) - 1;
251 /* Now we are committed to check them out */
252 memset(&state, 0, sizeof(state));
254 state.refresh_cache = 1;
255 for (pos = 0; pos < active_nr; pos++) {
256 struct cache_entry *ce = active_cache[pos];
257 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
259 errs |= checkout_entry(ce, &state, NULL);
263 errs |= checkout_stage(stage, ce, pos, &state);
265 errs |= checkout_merged(pos, &state);
266 pos = skip_same_name(ce, pos) - 1;
270 if (write_cache(newfd, active_cache, active_nr) ||
271 commit_locked_index(lock_file))
272 die("unable to write new index file");
274 resolve_ref("HEAD", rev, 0, &flag);
275 head = lookup_commit_reference_gently(rev, 1);
277 errs |= post_checkout_hook(head, head, 0);
281 static void show_local_changes(struct object *head)
284 /* I think we want full paths, even if we're in a subdirectory. */
285 init_revisions(&rev, NULL);
287 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
288 if (diff_setup_done(&rev.diffopt) < 0)
289 die("diff_setup_done failed");
290 add_pending_object(&rev, head, NULL);
291 run_diff_index(&rev, 0);
294 static void describe_detached_head(char *msg, struct commit *commit)
296 struct strbuf sb = STRBUF_INIT;
297 struct pretty_print_context ctx = {0};
298 parse_commit(commit);
299 pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
300 fprintf(stderr, "%s %s... %s\n", msg,
301 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
305 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
307 struct unpack_trees_options opts;
308 struct tree_desc tree_desc;
310 memset(&opts, 0, sizeof(opts));
312 opts.update = worktree;
313 opts.skip_unmerged = !worktree;
316 opts.fn = oneway_merge;
317 opts.verbose_update = !o->quiet;
318 opts.src_index = &the_index;
319 opts.dst_index = &the_index;
321 init_tree_desc(&tree_desc, tree->buffer, tree->size);
322 switch (unpack_trees(1, &tree_desc, &opts)) {
324 o->writeout_error = 1;
326 * We return 0 nevertheless, as the index is all right
327 * and more importantly we have made best efforts to
328 * update paths in the work tree, and we cannot revert
339 const char *name; /* The short name used */
340 const char *path; /* The full name of a real branch */
341 struct commit *commit; /* The named commit */
344 static void setup_branch_path(struct branch_info *branch)
346 struct strbuf buf = STRBUF_INIT;
348 strbuf_branchname(&buf, branch->name);
349 if (strcmp(buf.buf, branch->name))
350 branch->name = xstrdup(buf.buf);
351 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
352 branch->path = strbuf_detach(&buf, NULL);
355 static int merge_working_tree(struct checkout_opts *opts,
356 struct branch_info *old, struct branch_info *new)
359 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
360 int newfd = hold_locked_index(lock_file, 1);
362 if (read_cache_preload(NULL) < 0)
363 return error("corrupt index file");
365 resolve_undo_clear();
367 ret = reset_tree(new->commit->tree, opts, 1);
371 struct tree_desc trees[2];
373 struct unpack_trees_options topts;
375 memset(&topts, 0, sizeof(topts));
377 topts.src_index = &the_index;
378 topts.dst_index = &the_index;
380 topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
382 refresh_cache(REFRESH_QUIET);
384 if (unmerged_cache()) {
385 error("you need to resolve your current index first");
389 /* 2-way merge to the new branch */
390 topts.initial_checkout = is_cache_unborn();
393 topts.gently = opts->merge && old->commit;
394 topts.verbose_update = !opts->quiet;
395 topts.fn = twoway_merge;
396 topts.dir = xcalloc(1, sizeof(*topts.dir));
397 topts.dir->flags |= DIR_SHOW_IGNORED;
398 topts.dir->exclude_per_dir = ".gitignore";
399 tree = parse_tree_indirect(old->commit ?
400 old->commit->object.sha1 :
401 (unsigned char *)EMPTY_TREE_SHA1_BIN);
402 init_tree_desc(&trees[0], tree->buffer, tree->size);
403 tree = parse_tree_indirect(new->commit->object.sha1);
404 init_tree_desc(&trees[1], tree->buffer, tree->size);
406 ret = unpack_trees(2, trees, &topts);
409 * Unpack couldn't do a trivial merge; either
410 * give up or do a real merge, depending on
411 * whether the merge flag was used.
415 struct merge_options o;
420 * Without old->commit, the below is the same as
421 * the two-tree unpack we already tried and failed.
426 /* Do more real merge */
429 * We update the index fully, then write the
430 * tree from the index, then merge the new
431 * branch with the current tree, with the old
432 * branch as the base. Then we reset the index
433 * (but not the working tree) to the new
434 * branch, leaving the working tree as the
435 * merged version, but skipping unmerged
436 * entries in the index.
439 add_files_to_cache(NULL, NULL, 0);
440 init_merge_options(&o);
442 work = write_tree_from_memory(&o);
444 ret = reset_tree(new->commit->tree, opts, 1);
447 o.ancestor = old->name;
448 o.branch1 = new->name;
450 merge_trees(&o, new->commit->tree, work,
451 old->commit->tree, &result);
452 ret = reset_tree(new->commit->tree, opts, 0);
458 if (write_cache(newfd, active_cache, active_nr) ||
459 commit_locked_index(lock_file))
460 die("unable to write new index file");
462 if (!opts->force && !opts->quiet)
463 show_local_changes(&new->commit->object);
468 static void report_tracking(struct branch_info *new)
470 struct strbuf sb = STRBUF_INIT;
471 struct branch *branch = branch_get(new->name);
473 if (!format_tracking_info(branch, &sb))
475 fputs(sb.buf, stdout);
479 static void detach_advice(const char *old_path, const char *new_name)
482 "Note: checking out '%s'.\n\n"
483 "You are in 'detached HEAD' state. You can look around, make experimental\n"
484 "changes and commit them, and you can discard any commits you make in this\n"
485 "state without impacting any branches by performing another checkout.\n\n"
486 "If you want to create a new branch to retain commits you create, you may\n"
487 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
488 " git checkout -b new_branch_name\n\n";
490 fprintf(stderr, fmt, new_name);
493 static void update_refs_for_switch(struct checkout_opts *opts,
494 struct branch_info *old,
495 struct branch_info *new)
497 struct strbuf msg = STRBUF_INIT;
498 const char *old_desc;
499 if (opts->new_branch) {
500 if (opts->new_orphan_branch) {
501 if (opts->new_branch_log && !log_all_ref_updates) {
503 char log_file[PATH_MAX];
504 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
506 temp = log_all_ref_updates;
507 log_all_ref_updates = 1;
508 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
509 fprintf(stderr, "Can not do reflog for '%s'\n",
510 opts->new_orphan_branch);
511 log_all_ref_updates = temp;
514 log_all_ref_updates = temp;
518 create_branch(old->name, opts->new_branch, new->name, 0,
519 opts->new_branch_log, opts->track);
520 new->name = opts->new_branch;
521 setup_branch_path(new);
524 old_desc = old->name;
525 if (!old_desc && old->commit)
526 old_desc = sha1_to_hex(old->commit->object.sha1);
527 strbuf_addf(&msg, "checkout: moving from %s to %s",
528 old_desc ? old_desc : "(invalid)", new->name);
531 create_symref("HEAD", new->path, msg.buf);
533 if (old->path && !strcmp(new->path, old->path))
534 fprintf(stderr, "Already on '%s'\n",
537 fprintf(stderr, "Switched to%s branch '%s'\n",
538 opts->new_branch ? " a new" : "",
541 if (old->path && old->name) {
542 char log_file[PATH_MAX], ref_file[PATH_MAX];
544 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
545 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
546 if (!file_exists(ref_file) && file_exists(log_file))
547 remove_path(log_file);
549 } else if (strcmp(new->name, "HEAD")) {
550 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
551 REF_NODEREF, DIE_ON_ERR);
553 if (old->path && advice_detached_head)
554 detach_advice(old->path, new->name);
555 describe_detached_head("HEAD is now at", new->commit);
558 remove_branch_state();
559 strbuf_release(&msg);
560 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
561 report_tracking(new);
564 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
567 struct branch_info old;
568 unsigned char rev[20];
570 memset(&old, 0, sizeof(old));
571 old.path = resolve_ref("HEAD", rev, 0, &flag);
572 old.commit = lookup_commit_reference_gently(rev, 1);
573 if (!(flag & REF_ISSYMREF))
576 if (old.path && !prefixcmp(old.path, "refs/heads/"))
577 old.name = old.path + strlen("refs/heads/");
581 new->commit = old.commit;
583 die("You are on a branch yet to be born");
584 parse_commit(new->commit);
587 ret = merge_working_tree(opts, &old, new);
592 * If we were on a detached HEAD, but have now moved to
593 * a new commit, we want to mention the old commit once more
594 * to remind the user that it might be lost.
596 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
597 describe_detached_head("Previous HEAD position was", old.commit);
599 update_refs_for_switch(opts, &old, new);
601 ret = post_checkout_hook(old.commit, new->commit, 1);
602 return ret || opts->writeout_error;
605 static int git_checkout_config(const char *var, const char *value, void *cb)
607 return git_xmerge_config(var, value, cb);
610 static int interactive_checkout(const char *revision, const char **pathspec,
611 struct checkout_opts *opts)
613 return run_add_interactive(revision, "--patch=checkout", pathspec);
616 struct tracking_name_data {
622 static int check_tracking_name(const char *refname, const unsigned char *sha1,
623 int flags, void *cb_data)
625 struct tracking_name_data *cb = cb_data;
628 if (prefixcmp(refname, "refs/remotes/"))
630 slash = strchr(refname + 13, '/');
631 if (!slash || strcmp(slash + 1, cb->name))
637 cb->remote = xstrdup(refname);
641 static const char *unique_tracking_name(const char *name)
643 struct tracking_name_data cb_data = { NULL, NULL, 1 };
645 for_each_ref(check_tracking_name, &cb_data);
647 return cb_data.remote;
648 free(cb_data.remote);
652 int cmd_checkout(int argc, const char **argv, const char *prefix)
654 struct checkout_opts opts;
655 unsigned char rev[20];
657 struct branch_info new;
658 struct tree *source_tree = NULL;
659 char *conflict_style = NULL;
661 int dwim_new_local_branch = 1;
662 struct option options[] = {
663 OPT__QUIET(&opts.quiet),
664 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
665 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
666 OPT_SET_INT('t', "track", &opts.track, "track",
667 BRANCH_TRACK_EXPLICIT),
668 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
669 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
671 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
673 OPT_BOOLEAN('f', "force", &opts.force, "force"),
674 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
675 OPT_STRING(0, "conflict", &conflict_style, "style",
676 "conflict style (merge or diff3)"),
677 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
678 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
679 "second guess 'git checkout no-such-branch'",
680 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
685 memset(&opts, 0, sizeof(opts));
686 memset(&new, 0, sizeof(new));
688 git_config(git_checkout_config, NULL);
690 opts.track = BRANCH_TRACK_UNSPECIFIED;
692 argc = parse_options(argc, argv, prefix, options, checkout_usage,
693 PARSE_OPT_KEEP_DASHDASH);
695 if (patch_mode && (opts.track > 0 || opts.new_branch
696 || opts.new_branch_log || opts.merge || opts.force))
697 die ("--patch is incompatible with all other options");
699 /* --track without -b should DWIM */
700 if (0 < opts.track && !opts.new_branch) {
701 const char *argv0 = argv[0];
702 if (!argc || !strcmp(argv0, "--"))
703 die ("--track needs a branch name");
704 if (!prefixcmp(argv0, "refs/"))
706 if (!prefixcmp(argv0, "remotes/"))
708 argv0 = strchr(argv0, '/');
709 if (!argv0 || !argv0[1])
710 die ("Missing branch name; try -b");
711 opts.new_branch = argv0 + 1;
714 if (opts.new_orphan_branch) {
716 die("--orphan and -b are mutually exclusive");
718 die("--orphan cannot be used with -t");
719 opts.new_branch = opts.new_orphan_branch;
722 if (conflict_style) {
723 opts.merge = 1; /* implied */
724 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
727 if (opts.force && opts.merge)
728 die("git checkout: -f and -m are incompatible");
731 * case 1: git checkout <ref> -- [<paths>]
733 * <ref> must be a valid tree, everything after the '--' must be
736 * case 2: git checkout -- [<paths>]
738 * everything after the '--' must be paths.
740 * case 3: git checkout <something> [<paths>]
742 * With no paths, if <something> is a commit, that is to
743 * switch to the branch or detach HEAD at it. As a special case,
744 * if <something> is A...B (missing A or B means HEAD but you can
745 * omit at most one side), and if there is a unique merge base
746 * between A and B, A...B names that merge base.
748 * With no paths, if <something> is _not_ a commit, no -t nor -b
749 * was given, and there is a tracking branch whose name is
750 * <something> in one and only one remote, then this is a short-hand
751 * to fork local <something> from that remote tracking branch.
753 * Otherwise <something> shall not be ambiguous.
754 * - If it's *only* a reference, treat it like case (1).
755 * - If it's only a path, treat it like case (2).
760 if (!strcmp(argv[0], "--")) { /* case (2) */
767 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
769 if (!strcmp(arg, "-"))
772 if (get_sha1_mb(arg, rev)) {
773 if (has_dash_dash) /* case (1) */
774 die("invalid reference: %s", arg);
776 dwim_new_local_branch &&
777 opts.track == BRANCH_TRACK_UNSPECIFIED &&
779 !check_filename(NULL, arg) &&
781 const char *remote = unique_tracking_name(arg);
782 if (!remote || get_sha1(remote, rev))
784 opts.new_branch = arg;
786 /* DWIMmed to create local branch */
792 /* we can't end up being in (2) anymore, eat the argument */
797 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
798 setup_branch_path(&new);
800 if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
801 resolve_ref(new.path, rev, 1, NULL))
805 parse_commit(new.commit);
806 source_tree = new.commit->tree;
808 source_tree = parse_tree_indirect(rev);
810 if (!source_tree) /* case (1): want a tree */
811 die("reference is not a tree: %s", arg);
812 if (!has_dash_dash) {/* case (3 -> 1) */
814 * Do not complain the most common case
815 * git checkout branch
816 * even if there happen to be a file called 'branch';
817 * it would be extremely annoying.
820 verify_non_filename(NULL, arg);
830 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
831 opts.track = git_branch_track;
834 const char **pathspec = get_pathspec(prefix, argv);
837 die("invalid path specification");
840 return interactive_checkout(new.name, pathspec, &opts);
843 if (opts.new_branch) {
845 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]);
847 die("git checkout: updating paths is incompatible with switching branches.");
851 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
852 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
854 return checkout_paths(source_tree, pathspec, &opts);
858 return interactive_checkout(new.name, NULL, &opts);
860 if (opts.new_branch) {
861 struct strbuf buf = STRBUF_INIT;
862 if (strbuf_check_branch_ref(&buf, opts.new_branch))
863 die("git checkout: we do not like '%s' as a branch name.",
865 if (!get_sha1(buf.buf, rev))
866 die("git checkout: branch %s already exists", opts.new_branch);
867 strbuf_release(&buf);
870 if (new.name && !new.commit) {
871 die("Cannot switch branch to a non-commit.");
873 if (opts.writeout_stage)
874 die("--ours/--theirs is incompatible with switching branches.");
876 return switch_branches(&opts, &new);