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"
21 #include "submodule.h"
22 #include "argv-array.h"
24 static const char * const checkout_usage[] = {
25 "git checkout [options] <branch>",
26 "git checkout [options] [<branch>] -- <file>...",
30 struct checkout_opts {
39 /* not set by parse_options */
42 const char *new_branch;
43 const char *new_branch_force;
44 const char *new_orphan_branch;
46 enum branch_track track;
47 struct diff_options diff_options;
50 static int post_checkout_hook(struct commit *old, struct commit *new,
53 return run_hook(NULL, "post-checkout",
54 sha1_to_hex(old ? old->object.sha1 : null_sha1),
55 sha1_to_hex(new ? new->object.sha1 : null_sha1),
56 changed ? "1" : "0", NULL);
57 /* "new" can be NULL when checking out from the index before
62 static int update_some(const unsigned char *sha1, const char *base, int baselen,
63 const char *pathname, unsigned mode, int stage, void *context)
66 struct cache_entry *ce;
69 return READ_TREE_RECURSIVE;
71 len = baselen + strlen(pathname);
72 ce = xcalloc(1, cache_entry_size(len));
73 hashcpy(ce->sha1, sha1);
74 memcpy(ce->name, base, baselen);
75 memcpy(ce->name + baselen, pathname, len - baselen);
76 ce->ce_flags = create_ce_flags(len, 0) | CE_UPDATE;
77 ce->ce_mode = create_ce_mode(mode);
78 add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
82 static int read_tree_some(struct tree *tree, const char **pathspec)
85 init_pathspec(&ps, pathspec);
86 read_tree_recursive(tree, "", 0, 0, &ps, update_some, NULL);
89 /* update the index with the given tree's info
90 * for all args, expanding wildcards, and exit
91 * with any non-zero return code.
96 static int skip_same_name(struct cache_entry *ce, int pos)
98 while (++pos < active_nr &&
99 !strcmp(active_cache[pos]->name, ce->name))
104 static int check_stage(int stage, struct cache_entry *ce, int pos)
106 while (pos < active_nr &&
107 !strcmp(active_cache[pos]->name, ce->name)) {
108 if (ce_stage(active_cache[pos]) == stage)
113 return error(_("path '%s' does not have our version"), ce->name);
115 return error(_("path '%s' does not have their version"), ce->name);
118 static int check_all_stages(struct cache_entry *ce, int pos)
120 if (ce_stage(ce) != 1 ||
121 active_nr <= pos + 2 ||
122 strcmp(active_cache[pos+1]->name, ce->name) ||
123 ce_stage(active_cache[pos+1]) != 2 ||
124 strcmp(active_cache[pos+2]->name, ce->name) ||
125 ce_stage(active_cache[pos+2]) != 3)
126 return error(_("path '%s' does not have all three versions"),
131 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
132 struct checkout *state)
134 while (pos < active_nr &&
135 !strcmp(active_cache[pos]->name, ce->name)) {
136 if (ce_stage(active_cache[pos]) == stage)
137 return checkout_entry(active_cache[pos], state, NULL);
141 return error(_("path '%s' does not have our version"), ce->name);
143 return error(_("path '%s' does not have their version"), ce->name);
146 static int checkout_merged(int pos, struct checkout *state)
148 struct cache_entry *ce = active_cache[pos];
149 const char *path = ce->name;
150 mmfile_t ancestor, ours, theirs;
152 unsigned char sha1[20];
153 mmbuffer_t result_buf;
155 if (ce_stage(ce) != 1 ||
156 active_nr <= pos + 2 ||
157 strcmp(active_cache[pos+1]->name, path) ||
158 ce_stage(active_cache[pos+1]) != 2 ||
159 strcmp(active_cache[pos+2]->name, path) ||
160 ce_stage(active_cache[pos+2]) != 3)
161 return error(_("path '%s' does not have all 3 versions"), path);
163 read_mmblob(&ancestor, active_cache[pos]->sha1);
164 read_mmblob(&ours, active_cache[pos+1]->sha1);
165 read_mmblob(&theirs, active_cache[pos+2]->sha1);
168 * NEEDSWORK: re-create conflicts from merges with
169 * merge.renormalize set, too
171 status = ll_merge(&result_buf, path, &ancestor, "base",
172 &ours, "ours", &theirs, "theirs", NULL);
176 if (status < 0 || !result_buf.ptr) {
177 free(result_buf.ptr);
178 return error(_("path '%s': cannot merge"), path);
183 * There is absolutely no reason to write this as a blob object
184 * and create a phony cache entry just to leak. This hack is
185 * primarily to get to the write_entry() machinery that massages
186 * the contents to work-tree format and writes out which only
187 * allows it for a cache entry. The code in write_entry() needs
188 * to be refactored to allow us to feed a <buffer, size, mode>
189 * instead of a cache entry. Such a refactoring would help
190 * merge_recursive as well (it also writes the merge result to the
191 * object database even when it may contain conflicts).
193 if (write_sha1_file(result_buf.ptr, result_buf.size,
195 die(_("Unable to add merge result for '%s'"), path);
196 ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
200 die(_("make_cache_entry failed for path '%s'"), path);
201 status = checkout_entry(ce, state, NULL);
205 static int checkout_paths(struct tree *source_tree, const char **pathspec,
206 const char *prefix, struct checkout_opts *opts)
209 struct checkout state;
210 static char *ps_matched;
211 unsigned char rev[20];
215 int stage = opts->writeout_stage;
216 int merge = opts->merge;
218 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
220 newfd = hold_locked_index(lock_file, 1);
221 if (read_cache_preload(pathspec) < 0)
222 return error(_("corrupt index file"));
225 read_tree_some(source_tree, pathspec);
227 for (pos = 0; pathspec[pos]; pos++)
229 ps_matched = xcalloc(1, pos);
231 for (pos = 0; pos < active_nr; pos++) {
232 struct cache_entry *ce = active_cache[pos];
233 if (source_tree && !(ce->ce_flags & CE_UPDATE))
235 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
238 if (report_path_error(ps_matched, pathspec, prefix))
241 /* "checkout -m path" to recreate conflicted state */
243 unmerge_cache(pathspec);
245 /* Any unmerged paths? */
246 for (pos = 0; pos < active_nr; pos++) {
247 struct cache_entry *ce = active_cache[pos];
248 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
252 warning(_("path '%s' is unmerged"), ce->name);
254 errs |= check_stage(stage, ce, pos);
255 } else if (opts->merge) {
256 errs |= check_all_stages(ce, pos);
259 error(_("path '%s' is unmerged"), ce->name);
261 pos = skip_same_name(ce, pos) - 1;
267 /* Now we are committed to check them out */
268 memset(&state, 0, sizeof(state));
270 state.refresh_cache = 1;
271 for (pos = 0; pos < active_nr; pos++) {
272 struct cache_entry *ce = active_cache[pos];
273 if (source_tree && !(ce->ce_flags & CE_UPDATE))
275 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
277 errs |= checkout_entry(ce, &state, NULL);
281 errs |= checkout_stage(stage, ce, pos, &state);
283 errs |= checkout_merged(pos, &state);
284 pos = skip_same_name(ce, pos) - 1;
288 if (write_cache(newfd, active_cache, active_nr) ||
289 commit_locked_index(lock_file))
290 die(_("unable to write new index file"));
292 resolve_ref("HEAD", rev, 0, &flag);
293 head = lookup_commit_reference_gently(rev, 1);
295 errs |= post_checkout_hook(head, head, 0);
299 static void show_local_changes(struct object *head, struct diff_options *opts)
302 /* I think we want full paths, even if we're in a subdirectory. */
303 init_revisions(&rev, NULL);
304 rev.diffopt.flags = opts->flags;
305 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
306 if (diff_setup_done(&rev.diffopt) < 0)
307 die(_("diff_setup_done failed"));
308 add_pending_object(&rev, head, NULL);
309 run_diff_index(&rev, 0);
312 static void describe_detached_head(const char *msg, struct commit *commit)
314 struct strbuf sb = STRBUF_INIT;
315 parse_commit(commit);
316 pp_commit_easy(CMIT_FMT_ONELINE, commit, &sb);
317 fprintf(stderr, "%s %s... %s\n", msg,
318 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
322 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
324 struct unpack_trees_options opts;
325 struct tree_desc tree_desc;
327 memset(&opts, 0, sizeof(opts));
329 opts.update = worktree;
330 opts.skip_unmerged = !worktree;
333 opts.fn = oneway_merge;
334 opts.verbose_update = !o->quiet;
335 opts.src_index = &the_index;
336 opts.dst_index = &the_index;
338 init_tree_desc(&tree_desc, tree->buffer, tree->size);
339 switch (unpack_trees(1, &tree_desc, &opts)) {
341 o->writeout_error = 1;
343 * We return 0 nevertheless, as the index is all right
344 * and more importantly we have made best efforts to
345 * update paths in the work tree, and we cannot revert
356 const char *name; /* The short name used */
357 const char *path; /* The full name of a real branch */
358 struct commit *commit; /* The named commit */
361 static void setup_branch_path(struct branch_info *branch)
363 struct strbuf buf = STRBUF_INIT;
365 strbuf_branchname(&buf, branch->name);
366 if (strcmp(buf.buf, branch->name))
367 branch->name = xstrdup(buf.buf);
368 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
369 branch->path = strbuf_detach(&buf, NULL);
372 static int merge_working_tree(struct checkout_opts *opts,
373 struct branch_info *old, struct branch_info *new)
376 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
377 int newfd = hold_locked_index(lock_file, 1);
379 if (read_cache_preload(NULL) < 0)
380 return error(_("corrupt index file"));
382 resolve_undo_clear();
384 ret = reset_tree(new->commit->tree, opts, 1);
388 struct tree_desc trees[2];
390 struct unpack_trees_options topts;
392 memset(&topts, 0, sizeof(topts));
394 topts.src_index = &the_index;
395 topts.dst_index = &the_index;
397 setup_unpack_trees_porcelain(&topts, "checkout");
399 refresh_cache(REFRESH_QUIET);
401 if (unmerged_cache()) {
402 error(_("you need to resolve your current index first"));
406 /* 2-way merge to the new branch */
407 topts.initial_checkout = is_cache_unborn();
410 topts.gently = opts->merge && old->commit;
411 topts.verbose_update = !opts->quiet;
412 topts.fn = twoway_merge;
413 if (opts->overwrite_ignore) {
414 topts.dir = xcalloc(1, sizeof(*topts.dir));
415 topts.dir->flags |= DIR_SHOW_IGNORED;
416 setup_standard_excludes(topts.dir);
418 tree = parse_tree_indirect(old->commit ?
419 old->commit->object.sha1 :
420 EMPTY_TREE_SHA1_BIN);
421 init_tree_desc(&trees[0], tree->buffer, tree->size);
422 tree = parse_tree_indirect(new->commit->object.sha1);
423 init_tree_desc(&trees[1], tree->buffer, tree->size);
425 ret = unpack_trees(2, trees, &topts);
428 * Unpack couldn't do a trivial merge; either
429 * give up or do a real merge, depending on
430 * whether the merge flag was used.
434 struct merge_options o;
439 * Without old->commit, the below is the same as
440 * the two-tree unpack we already tried and failed.
445 /* Do more real merge */
448 * We update the index fully, then write the
449 * tree from the index, then merge the new
450 * branch with the current tree, with the old
451 * branch as the base. Then we reset the index
452 * (but not the working tree) to the new
453 * branch, leaving the working tree as the
454 * merged version, but skipping unmerged
455 * entries in the index.
458 add_files_to_cache(NULL, NULL, 0);
460 * NEEDSWORK: carrying over local changes
461 * when branches have different end-of-line
462 * normalization (or clean+smudge rules) is
463 * a pain; plumb in an option to set
466 init_merge_options(&o);
468 work = write_tree_from_memory(&o);
470 ret = reset_tree(new->commit->tree, opts, 1);
473 o.ancestor = old->name;
474 o.branch1 = new->name;
476 merge_trees(&o, new->commit->tree, work,
477 old->commit->tree, &result);
478 ret = reset_tree(new->commit->tree, opts, 0);
484 if (write_cache(newfd, active_cache, active_nr) ||
485 commit_locked_index(lock_file))
486 die(_("unable to write new index file"));
488 if (!opts->force && !opts->quiet)
489 show_local_changes(&new->commit->object, &opts->diff_options);
494 static void report_tracking(struct branch_info *new)
496 struct strbuf sb = STRBUF_INIT;
497 struct branch *branch = branch_get(new->name);
499 if (!format_tracking_info(branch, &sb))
501 fputs(sb.buf, stdout);
505 static void detach_advice(const char *old_path, const char *new_name)
508 "Note: checking out '%s'.\n\n"
509 "You are in 'detached HEAD' state. You can look around, make experimental\n"
510 "changes and commit them, and you can discard any commits you make in this\n"
511 "state without impacting any branches by performing another checkout.\n\n"
512 "If you want to create a new branch to retain commits you create, you may\n"
513 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
514 " git checkout -b new_branch_name\n\n";
516 fprintf(stderr, fmt, new_name);
519 static void update_refs_for_switch(struct checkout_opts *opts,
520 struct branch_info *old,
521 struct branch_info *new)
523 struct strbuf msg = STRBUF_INIT;
524 const char *old_desc;
525 if (opts->new_branch) {
526 if (opts->new_orphan_branch) {
527 if (opts->new_branch_log && !log_all_ref_updates) {
529 char log_file[PATH_MAX];
530 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
532 temp = log_all_ref_updates;
533 log_all_ref_updates = 1;
534 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
535 fprintf(stderr, _("Can not do reflog for '%s'\n"),
536 opts->new_orphan_branch);
537 log_all_ref_updates = temp;
540 log_all_ref_updates = temp;
544 create_branch(old->name, opts->new_branch, new->name,
545 opts->new_branch_force ? 1 : 0,
546 opts->new_branch_log, opts->track);
547 new->name = opts->new_branch;
548 setup_branch_path(new);
551 old_desc = old->name;
552 if (!old_desc && old->commit)
553 old_desc = sha1_to_hex(old->commit->object.sha1);
554 strbuf_addf(&msg, "checkout: moving from %s to %s",
555 old_desc ? old_desc : "(invalid)", new->name);
557 if (!strcmp(new->name, "HEAD") && !new->path && !opts->force_detach) {
559 } else if (opts->force_detach || !new->path) { /* No longer on any branch. */
560 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
561 REF_NODEREF, DIE_ON_ERR);
563 if (old->path && advice_detached_head)
564 detach_advice(old->path, new->name);
565 describe_detached_head(_("HEAD is now at"), new->commit);
567 } else if (new->path) { /* Switch branches. */
568 create_symref("HEAD", new->path, msg.buf);
570 if (old->path && !strcmp(new->path, old->path)) {
571 fprintf(stderr, _("Already on '%s'\n"),
573 } else if (opts->new_branch) {
574 if (opts->branch_exists)
575 fprintf(stderr, _("Switched to and reset branch '%s'\n"), new->name);
577 fprintf(stderr, _("Switched to a new branch '%s'\n"), new->name);
579 fprintf(stderr, _("Switched to branch '%s'\n"),
583 if (old->path && old->name) {
584 char log_file[PATH_MAX], ref_file[PATH_MAX];
586 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
587 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
588 if (!file_exists(ref_file) && file_exists(log_file))
589 remove_path(log_file);
592 remove_branch_state();
593 strbuf_release(&msg);
595 (new->path || (!opts->force_detach && !strcmp(new->name, "HEAD"))))
596 report_tracking(new);
599 static int add_pending_uninteresting_ref(const char *refname,
600 const unsigned char *sha1,
601 int flags, void *cb_data)
603 add_pending_sha1(cb_data, refname, sha1, flags | UNINTERESTING);
607 static void describe_one_orphan(struct strbuf *sb, struct commit *commit)
609 parse_commit(commit);
610 strbuf_addstr(sb, " ");
612 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
613 strbuf_addch(sb, ' ');
614 pp_commit_easy(CMIT_FMT_ONELINE, commit, sb);
615 strbuf_addch(sb, '\n');
618 #define ORPHAN_CUTOFF 4
619 static void suggest_reattach(struct commit *commit, struct rev_info *revs)
621 struct commit *c, *last = NULL;
622 struct strbuf sb = STRBUF_INIT;
624 while ((c = get_revision(revs)) != NULL) {
625 if (lost < ORPHAN_CUTOFF)
626 describe_one_orphan(&sb, c);
630 if (ORPHAN_CUTOFF < lost) {
631 int more = lost - ORPHAN_CUTOFF;
633 describe_one_orphan(&sb, last);
635 strbuf_addf(&sb, _(" ... and %d more.\n"), more);
640 /* The singular version */
641 "Warning: you are leaving %d commit behind, "
643 "any of your branches:\n\n"
645 /* The plural version */
646 "Warning: you are leaving %d commits behind, "
648 "any of your branches:\n\n"
650 /* Give ngettext() the count */
656 if (advice_detached_head)
659 "If you want to keep them by creating a new branch, "
660 "this may be a good time\nto do so with:\n\n"
661 " git branch new_branch_name %s\n\n"),
662 sha1_to_hex(commit->object.sha1));
666 * We are about to leave commit that was at the tip of a detached
667 * HEAD. If it is not reachable from any ref, this is the last chance
668 * for the user to do so without resorting to reflog.
670 static void orphaned_commit_warning(struct commit *commit)
672 struct rev_info revs;
673 struct object *object = &commit->object;
674 struct object_array refs;
676 init_revisions(&revs, NULL);
677 setup_revisions(0, NULL, &revs, NULL);
679 object->flags &= ~UNINTERESTING;
680 add_pending_object(&revs, object, sha1_to_hex(object->sha1));
682 for_each_ref(add_pending_uninteresting_ref, &revs);
685 revs.leak_pending = 1;
687 if (prepare_revision_walk(&revs))
688 die(_("internal error in revision walk"));
689 if (!(commit->object.flags & UNINTERESTING))
690 suggest_reattach(commit, &revs);
692 describe_detached_head(_("Previous HEAD position was"), commit);
694 clear_commit_marks_for_object_array(&refs, ALL_REV_FLAGS);
698 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
701 struct branch_info old;
702 unsigned char rev[20];
704 memset(&old, 0, sizeof(old));
705 old.path = xstrdup(resolve_ref("HEAD", rev, 0, &flag));
706 old.commit = lookup_commit_reference_gently(rev, 1);
707 if (!(flag & REF_ISSYMREF)) {
708 free((char *)old.path);
712 if (old.path && !prefixcmp(old.path, "refs/heads/"))
713 old.name = old.path + strlen("refs/heads/");
717 new->commit = old.commit;
719 die(_("You are on a branch yet to be born"));
720 parse_commit(new->commit);
723 ret = merge_working_tree(opts, &old, new);
727 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
728 orphaned_commit_warning(old.commit);
730 update_refs_for_switch(opts, &old, new);
732 ret = post_checkout_hook(old.commit, new->commit, 1);
733 free((char *)old.path);
734 return ret || opts->writeout_error;
737 static int git_checkout_config(const char *var, const char *value, void *cb)
739 if (!strcmp(var, "diff.ignoresubmodules")) {
740 struct checkout_opts *opts = cb;
741 handle_ignore_submodules_arg(&opts->diff_options, value);
745 if (!prefixcmp(var, "submodule."))
746 return parse_submodule_config_option(var, value);
748 return git_xmerge_config(var, value, NULL);
751 static int interactive_checkout(const char *revision, const char **pathspec,
752 struct checkout_opts *opts)
754 return run_add_interactive(revision, "--patch=checkout", pathspec);
757 struct tracking_name_data {
763 static int check_tracking_name(const char *refname, const unsigned char *sha1,
764 int flags, void *cb_data)
766 struct tracking_name_data *cb = cb_data;
769 if (prefixcmp(refname, "refs/remotes/"))
771 slash = strchr(refname + 13, '/');
772 if (!slash || strcmp(slash + 1, cb->name))
778 cb->remote = xstrdup(refname);
782 static const char *unique_tracking_name(const char *name)
784 struct tracking_name_data cb_data = { NULL, NULL, 1 };
786 for_each_ref(check_tracking_name, &cb_data);
788 return cb_data.remote;
789 free(cb_data.remote);
793 static int parse_branchname_arg(int argc, const char **argv,
794 int dwim_new_local_branch_ok,
795 struct branch_info *new,
796 struct tree **source_tree,
797 unsigned char rev[20],
798 const char **new_branch)
801 unsigned char branch_rev[20];
806 * case 1: git checkout <ref> -- [<paths>]
808 * <ref> must be a valid tree, everything after the '--' must be
811 * case 2: git checkout -- [<paths>]
813 * everything after the '--' must be paths.
815 * case 3: git checkout <something> [<paths>]
817 * With no paths, if <something> is a commit, that is to
818 * switch to the branch or detach HEAD at it. As a special case,
819 * if <something> is A...B (missing A or B means HEAD but you can
820 * omit at most one side), and if there is a unique merge base
821 * between A and B, A...B names that merge base.
823 * With no paths, if <something> is _not_ a commit, no -t nor -b
824 * was given, and there is a tracking branch whose name is
825 * <something> in one and only one remote, then this is a short-hand
826 * to fork local <something> from that remote-tracking branch.
828 * Otherwise <something> shall not be ambiguous.
829 * - If it's *only* a reference, treat it like case (1).
830 * - If it's only a path, treat it like case (2).
837 if (!strcmp(argv[0], "--")) /* case (2) */
841 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
843 if (!strcmp(arg, "-"))
846 if (get_sha1_mb(arg, rev)) {
847 if (has_dash_dash) /* case (1) */
848 die(_("invalid reference: %s"), arg);
849 if (dwim_new_local_branch_ok &&
850 !check_filename(NULL, arg) &&
852 const char *remote = unique_tracking_name(arg);
853 if (!remote || get_sha1(remote, rev))
857 /* DWIMmed to create local branch */
863 /* we can't end up being in (2) anymore, eat the argument */
869 setup_branch_path(new);
871 if (!check_refname_format(new->path, 0) &&
872 resolve_ref(new->path, branch_rev, 1, NULL))
873 hashcpy(rev, branch_rev);
875 new->path = NULL; /* not an existing branch */
877 new->commit = lookup_commit_reference_gently(rev, 1);
880 *source_tree = parse_tree_indirect(rev);
882 parse_commit(new->commit);
883 *source_tree = new->commit->tree;
886 if (!*source_tree) /* case (1): want a tree */
887 die(_("reference is not a tree: %s"), arg);
888 if (!has_dash_dash) {/* case (3 -> 1) */
890 * Do not complain the most common case
891 * git checkout branch
892 * even if there happen to be a file called 'branch';
893 * it would be extremely annoying.
896 verify_non_filename(NULL, arg);
906 int cmd_checkout(int argc, const char **argv, const char *prefix)
908 struct checkout_opts opts;
909 unsigned char rev[20];
910 struct branch_info new;
911 struct tree *source_tree = NULL;
912 char *conflict_style = NULL;
914 int dwim_new_local_branch = 1;
915 struct option options[] = {
916 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
917 OPT_STRING('b', NULL, &opts.new_branch, "branch",
918 "create and checkout a new branch"),
919 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
920 "create/reset and checkout a branch"),
921 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
922 OPT_BOOLEAN(0, "detach", &opts.force_detach, "detach the HEAD at named commit"),
923 OPT_SET_INT('t', "track", &opts.track, "set upstream info for new branch",
924 BRANCH_TRACK_EXPLICIT),
925 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
926 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
928 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
930 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
931 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
932 OPT_BOOLEAN(0, "overwrite-ignore", &opts.overwrite_ignore, "update ignored files (default)"),
933 OPT_STRING(0, "conflict", &conflict_style, "style",
934 "conflict style (merge or diff3)"),
935 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
936 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
937 "second guess 'git checkout no-such-branch'",
938 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
942 memset(&opts, 0, sizeof(opts));
943 memset(&new, 0, sizeof(new));
944 opts.overwrite_ignore = 1;
947 git_config(git_checkout_config, &opts);
949 opts.track = BRANCH_TRACK_UNSPECIFIED;
951 argc = parse_options(argc, argv, prefix, options, checkout_usage,
952 PARSE_OPT_KEEP_DASHDASH);
954 /* we can assume from now on new_branch = !new_branch_force */
955 if (opts.new_branch && opts.new_branch_force)
956 die(_("-B cannot be used with -b"));
958 /* copy -B over to -b, so that we can just check the latter */
959 if (opts.new_branch_force)
960 opts.new_branch = opts.new_branch_force;
962 if (patch_mode && (opts.track > 0 || opts.new_branch
963 || opts.new_branch_log || opts.merge || opts.force
964 || opts.force_detach))
965 die (_("--patch is incompatible with all other options"));
967 if (opts.force_detach && (opts.new_branch || opts.new_orphan_branch))
968 die(_("--detach cannot be used with -b/-B/--orphan"));
969 if (opts.force_detach && 0 < opts.track)
970 die(_("--detach cannot be used with -t"));
972 /* --track without -b should DWIM */
973 if (0 < opts.track && !opts.new_branch) {
974 const char *argv0 = argv[0];
975 if (!argc || !strcmp(argv0, "--"))
976 die (_("--track needs a branch name"));
977 if (!prefixcmp(argv0, "refs/"))
979 if (!prefixcmp(argv0, "remotes/"))
981 argv0 = strchr(argv0, '/');
982 if (!argv0 || !argv0[1])
983 die (_("Missing branch name; try -b"));
984 opts.new_branch = argv0 + 1;
987 if (opts.new_orphan_branch) {
989 die(_("--orphan and -b|-B are mutually exclusive"));
991 die(_("--orphan cannot be used with -t"));
992 opts.new_branch = opts.new_orphan_branch;
995 if (conflict_style) {
996 opts.merge = 1; /* implied */
997 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
1000 if (opts.force && opts.merge)
1001 die(_("git checkout: -f and -m are incompatible"));
1004 * Extract branch name from command line arguments, so
1005 * all that is left is pathspecs.
1009 * 1) git checkout <tree> -- [<paths>]
1010 * 2) git checkout -- [<paths>]
1011 * 3) git checkout <something> [<paths>]
1013 * including "last branch" syntax and DWIM-ery for names of
1014 * remote branches, erroring out for invalid or ambiguous cases.
1019 dwim_new_local_branch &&
1020 opts.track == BRANCH_TRACK_UNSPECIFIED &&
1022 int n = parse_branchname_arg(argc, argv, dwim_ok,
1023 &new, &source_tree, rev, &opts.new_branch);
1028 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
1029 opts.track = git_branch_track;
1032 const char **pathspec = get_pathspec(prefix, argv);
1035 die(_("invalid path specification"));
1038 return interactive_checkout(new.name, pathspec, &opts);
1040 /* Checkout paths */
1041 if (opts.new_branch) {
1043 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]);
1045 die(_("git checkout: updating paths is incompatible with switching branches."));
1049 if (opts.force_detach)
1050 die(_("git checkout: --detach does not take a path argument"));
1052 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
1053 die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
1055 return checkout_paths(source_tree, pathspec, prefix, &opts);
1059 return interactive_checkout(new.name, NULL, &opts);
1061 if (opts.new_branch) {
1062 struct strbuf buf = STRBUF_INIT;
1064 opts.branch_exists = validate_new_branchname(opts.new_branch, &buf,
1065 !!opts.new_branch_force, 0);
1067 strbuf_release(&buf);
1070 if (new.name && !new.commit) {
1071 die(_("Cannot switch branch to a non-commit."));
1073 if (opts.writeout_stage)
1074 die(_("--ours/--theirs is incompatible with switching branches."));
1076 return switch_branches(&opts, &new);