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"
23 static const char * const checkout_usage
[] = {
24 "git checkout [options] <branch>",
25 "git checkout [options] [<branch>] -- <file>...",
29 struct checkout_opts
{
37 /* not set by parse_options */
40 const char *new_branch
;
41 const char *new_branch_force
;
42 const char *new_orphan_branch
;
44 enum branch_track track
;
45 struct diff_options diff_options
;
48 static int post_checkout_hook(struct commit
*old
, struct commit
*new,
51 return run_hook(NULL
, "post-checkout",
52 sha1_to_hex(old
? old
->object
.sha1
: null_sha1
),
53 sha1_to_hex(new ? new->object
.sha1
: null_sha1
),
54 changed
? "1" : "0", NULL
);
55 /* "new" can be NULL when checking out from the index before
60 static int update_some(const unsigned char *sha1
, const char *base
, int baselen
,
61 const char *pathname
, unsigned mode
, int stage
, void *context
)
64 struct cache_entry
*ce
;
67 return READ_TREE_RECURSIVE
;
69 len
= baselen
+ strlen(pathname
);
70 ce
= xcalloc(1, cache_entry_size(len
));
71 hashcpy(ce
->sha1
, sha1
);
72 memcpy(ce
->name
, base
, baselen
);
73 memcpy(ce
->name
+ baselen
, pathname
, len
- baselen
);
74 ce
->ce_flags
= create_ce_flags(len
, 0);
75 ce
->ce_mode
= create_ce_mode(mode
);
76 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
80 static int read_tree_some(struct tree
*tree
, const char **pathspec
)
82 read_tree_recursive(tree
, "", 0, 0, pathspec
, update_some
, NULL
);
84 /* update the index with the given tree's info
85 * for all args, expanding wildcards, and exit
86 * with any non-zero return code.
91 static int skip_same_name(struct cache_entry
*ce
, int pos
)
93 while (++pos
< active_nr
&&
94 !strcmp(active_cache
[pos
]->name
, ce
->name
))
99 static int check_stage(int stage
, struct cache_entry
*ce
, int pos
)
101 while (pos
< active_nr
&&
102 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
103 if (ce_stage(active_cache
[pos
]) == stage
)
107 return error("path '%s' does not have %s version",
109 (stage
== 2) ? "our" : "their");
112 static int check_all_stages(struct cache_entry
*ce
, int pos
)
114 if (ce_stage(ce
) != 1 ||
115 active_nr
<= pos
+ 2 ||
116 strcmp(active_cache
[pos
+1]->name
, ce
->name
) ||
117 ce_stage(active_cache
[pos
+1]) != 2 ||
118 strcmp(active_cache
[pos
+2]->name
, ce
->name
) ||
119 ce_stage(active_cache
[pos
+2]) != 3)
120 return error("path '%s' does not have all three versions",
125 static int checkout_stage(int stage
, struct cache_entry
*ce
, int pos
,
126 struct checkout
*state
)
128 while (pos
< active_nr
&&
129 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
130 if (ce_stage(active_cache
[pos
]) == stage
)
131 return checkout_entry(active_cache
[pos
], state
, NULL
);
134 return error("path '%s' does not have %s version",
136 (stage
== 2) ? "our" : "their");
139 static int checkout_merged(int pos
, struct checkout
*state
)
141 struct cache_entry
*ce
= active_cache
[pos
];
142 const char *path
= ce
->name
;
143 mmfile_t ancestor
, ours
, theirs
;
145 unsigned char sha1
[20];
146 mmbuffer_t result_buf
;
148 if (ce_stage(ce
) != 1 ||
149 active_nr
<= pos
+ 2 ||
150 strcmp(active_cache
[pos
+1]->name
, path
) ||
151 ce_stage(active_cache
[pos
+1]) != 2 ||
152 strcmp(active_cache
[pos
+2]->name
, path
) ||
153 ce_stage(active_cache
[pos
+2]) != 3)
154 return error("path '%s' does not have all 3 versions", path
);
156 read_mmblob(&ancestor
, active_cache
[pos
]->sha1
);
157 read_mmblob(&ours
, active_cache
[pos
+1]->sha1
);
158 read_mmblob(&theirs
, active_cache
[pos
+2]->sha1
);
161 * NEEDSWORK: re-create conflicts from merges with
162 * merge.renormalize set, too
164 status
= ll_merge(&result_buf
, path
, &ancestor
, "base",
165 &ours
, "ours", &theirs
, "theirs", 0);
169 if (status
< 0 || !result_buf
.ptr
) {
170 free(result_buf
.ptr
);
171 return error("path '%s': cannot merge", path
);
176 * There is absolutely no reason to write this as a blob object
177 * and create a phony cache entry just to leak. This hack is
178 * primarily to get to the write_entry() machinery that massages
179 * the contents to work-tree format and writes out which only
180 * allows it for a cache entry. The code in write_entry() needs
181 * to be refactored to allow us to feed a <buffer, size, mode>
182 * instead of a cache entry. Such a refactoring would help
183 * merge_recursive as well (it also writes the merge result to the
184 * object database even when it may contain conflicts).
186 if (write_sha1_file(result_buf
.ptr
, result_buf
.size
,
188 die("Unable to add merge result for '%s'", path
);
189 ce
= make_cache_entry(create_ce_mode(active_cache
[pos
+1]->ce_mode
),
193 die("make_cache_entry failed for path '%s'", path
);
194 status
= checkout_entry(ce
, state
, NULL
);
198 static int checkout_paths(struct tree
*source_tree
, const char **pathspec
,
199 struct checkout_opts
*opts
)
202 struct checkout state
;
203 static char *ps_matched
;
204 unsigned char rev
[20];
208 int stage
= opts
->writeout_stage
;
209 int merge
= opts
->merge
;
211 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
213 newfd
= hold_locked_index(lock_file
, 1);
214 if (read_cache_preload(pathspec
) < 0)
215 return error("corrupt index file");
218 read_tree_some(source_tree
, pathspec
);
220 for (pos
= 0; pathspec
[pos
]; pos
++)
222 ps_matched
= xcalloc(1, pos
);
224 for (pos
= 0; pos
< active_nr
; pos
++) {
225 struct cache_entry
*ce
= active_cache
[pos
];
226 match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, ps_matched
);
229 if (report_path_error(ps_matched
, pathspec
, 0))
232 /* "checkout -m path" to recreate conflicted state */
234 unmerge_cache(pathspec
);
236 /* Any unmerged paths? */
237 for (pos
= 0; pos
< active_nr
; pos
++) {
238 struct cache_entry
*ce
= active_cache
[pos
];
239 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
243 warning("path '%s' is unmerged", ce
->name
);
245 errs
|= check_stage(stage
, ce
, pos
);
246 } else if (opts
->merge
) {
247 errs
|= check_all_stages(ce
, pos
);
250 error("path '%s' is unmerged", ce
->name
);
252 pos
= skip_same_name(ce
, pos
) - 1;
258 /* Now we are committed to check them out */
259 memset(&state
, 0, sizeof(state
));
261 state
.refresh_cache
= 1;
262 for (pos
= 0; pos
< active_nr
; pos
++) {
263 struct cache_entry
*ce
= active_cache
[pos
];
264 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
266 errs
|= checkout_entry(ce
, &state
, NULL
);
270 errs
|= checkout_stage(stage
, ce
, pos
, &state
);
272 errs
|= checkout_merged(pos
, &state
);
273 pos
= skip_same_name(ce
, pos
) - 1;
277 if (write_cache(newfd
, active_cache
, active_nr
) ||
278 commit_locked_index(lock_file
))
279 die("unable to write new index file");
281 resolve_ref("HEAD", rev
, 0, &flag
);
282 head
= lookup_commit_reference_gently(rev
, 1);
284 errs
|= post_checkout_hook(head
, head
, 0);
288 static void show_local_changes(struct object
*head
, struct diff_options
*opts
)
291 /* I think we want full paths, even if we're in a subdirectory. */
292 init_revisions(&rev
, NULL
);
293 rev
.diffopt
.flags
= opts
->flags
;
294 rev
.diffopt
.output_format
|= DIFF_FORMAT_NAME_STATUS
;
295 if (diff_setup_done(&rev
.diffopt
) < 0)
296 die("diff_setup_done failed");
297 add_pending_object(&rev
, head
, NULL
);
298 run_diff_index(&rev
, 0);
301 static void describe_detached_head(char *msg
, struct commit
*commit
)
303 struct strbuf sb
= STRBUF_INIT
;
304 struct pretty_print_context ctx
= {0};
305 parse_commit(commit
);
306 pretty_print_commit(CMIT_FMT_ONELINE
, commit
, &sb
, &ctx
);
307 fprintf(stderr
, "%s %s... %s\n", msg
,
308 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
312 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
314 struct unpack_trees_options opts
;
315 struct tree_desc tree_desc
;
317 memset(&opts
, 0, sizeof(opts
));
319 opts
.update
= worktree
;
320 opts
.skip_unmerged
= !worktree
;
323 opts
.fn
= oneway_merge
;
324 opts
.verbose_update
= !o
->quiet
;
325 opts
.src_index
= &the_index
;
326 opts
.dst_index
= &the_index
;
328 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
329 switch (unpack_trees(1, &tree_desc
, &opts
)) {
331 o
->writeout_error
= 1;
333 * We return 0 nevertheless, as the index is all right
334 * and more importantly we have made best efforts to
335 * update paths in the work tree, and we cannot revert
346 const char *name
; /* The short name used */
347 const char *path
; /* The full name of a real branch */
348 struct commit
*commit
; /* The named commit */
351 static void setup_branch_path(struct branch_info
*branch
)
353 struct strbuf buf
= STRBUF_INIT
;
355 strbuf_branchname(&buf
, branch
->name
);
356 if (strcmp(buf
.buf
, branch
->name
))
357 branch
->name
= xstrdup(buf
.buf
);
358 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
359 branch
->path
= strbuf_detach(&buf
, NULL
);
362 static int merge_working_tree(struct checkout_opts
*opts
,
363 struct branch_info
*old
, struct branch_info
*new)
366 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
367 int newfd
= hold_locked_index(lock_file
, 1);
369 if (read_cache_preload(NULL
) < 0)
370 return error("corrupt index file");
372 resolve_undo_clear();
374 ret
= reset_tree(new->commit
->tree
, opts
, 1);
378 struct tree_desc trees
[2];
380 struct unpack_trees_options topts
;
382 memset(&topts
, 0, sizeof(topts
));
384 topts
.src_index
= &the_index
;
385 topts
.dst_index
= &the_index
;
387 setup_unpack_trees_porcelain(&topts
, "checkout");
389 refresh_cache(REFRESH_QUIET
);
391 if (unmerged_cache()) {
392 error("you need to resolve your current index first");
396 /* 2-way merge to the new branch */
397 topts
.initial_checkout
= is_cache_unborn();
400 topts
.gently
= opts
->merge
&& old
->commit
;
401 topts
.verbose_update
= !opts
->quiet
;
402 topts
.fn
= twoway_merge
;
403 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
404 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
405 topts
.dir
->exclude_per_dir
= ".gitignore";
406 tree
= parse_tree_indirect(old
->commit
?
407 old
->commit
->object
.sha1
:
408 (unsigned char *)EMPTY_TREE_SHA1_BIN
);
409 init_tree_desc(&trees
[0], tree
->buffer
, tree
->size
);
410 tree
= parse_tree_indirect(new->commit
->object
.sha1
);
411 init_tree_desc(&trees
[1], tree
->buffer
, tree
->size
);
413 ret
= unpack_trees(2, trees
, &topts
);
416 * Unpack couldn't do a trivial merge; either
417 * give up or do a real merge, depending on
418 * whether the merge flag was used.
422 struct merge_options o
;
427 * Without old->commit, the below is the same as
428 * the two-tree unpack we already tried and failed.
433 /* Do more real merge */
436 * We update the index fully, then write the
437 * tree from the index, then merge the new
438 * branch with the current tree, with the old
439 * branch as the base. Then we reset the index
440 * (but not the working tree) to the new
441 * branch, leaving the working tree as the
442 * merged version, but skipping unmerged
443 * entries in the index.
446 add_files_to_cache(NULL
, NULL
, 0);
448 * NEEDSWORK: carrying over local changes
449 * when branches have different end-of-line
450 * normalization (or clean+smudge rules) is
451 * a pain; plumb in an option to set
454 init_merge_options(&o
);
456 work
= write_tree_from_memory(&o
);
458 ret
= reset_tree(new->commit
->tree
, opts
, 1);
461 o
.ancestor
= old
->name
;
462 o
.branch1
= new->name
;
464 merge_trees(&o
, new->commit
->tree
, work
,
465 old
->commit
->tree
, &result
);
466 ret
= reset_tree(new->commit
->tree
, opts
, 0);
472 if (write_cache(newfd
, active_cache
, active_nr
) ||
473 commit_locked_index(lock_file
))
474 die("unable to write new index file");
476 if (!opts
->force
&& !opts
->quiet
)
477 show_local_changes(&new->commit
->object
, &opts
->diff_options
);
482 static void report_tracking(struct branch_info
*new)
484 struct strbuf sb
= STRBUF_INIT
;
485 struct branch
*branch
= branch_get(new->name
);
487 if (!format_tracking_info(branch
, &sb
))
489 fputs(sb
.buf
, stdout
);
493 static void detach_advice(const char *old_path
, const char *new_name
)
496 "Note: checking out '%s'.\n\n"
497 "You are in 'detached HEAD' state. You can look around, make experimental\n"
498 "changes and commit them, and you can discard any commits you make in this\n"
499 "state without impacting any branches by performing another checkout.\n\n"
500 "If you want to create a new branch to retain commits you create, you may\n"
501 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
502 " git checkout -b new_branch_name\n\n";
504 fprintf(stderr
, fmt
, new_name
);
507 static void update_refs_for_switch(struct checkout_opts
*opts
,
508 struct branch_info
*old
,
509 struct branch_info
*new)
511 struct strbuf msg
= STRBUF_INIT
;
512 const char *old_desc
;
513 if (opts
->new_branch
) {
514 if (opts
->new_orphan_branch
) {
515 if (opts
->new_branch_log
&& !log_all_ref_updates
) {
517 char log_file
[PATH_MAX
];
518 char *ref_name
= mkpath("refs/heads/%s", opts
->new_orphan_branch
);
520 temp
= log_all_ref_updates
;
521 log_all_ref_updates
= 1;
522 if (log_ref_setup(ref_name
, log_file
, sizeof(log_file
))) {
523 fprintf(stderr
, "Can not do reflog for '%s'\n",
524 opts
->new_orphan_branch
);
525 log_all_ref_updates
= temp
;
528 log_all_ref_updates
= temp
;
532 create_branch(old
->name
, opts
->new_branch
, new->name
,
533 opts
->new_branch_force
? 1 : 0,
534 opts
->new_branch_log
, opts
->track
);
535 new->name
= opts
->new_branch
;
536 setup_branch_path(new);
539 old_desc
= old
->name
;
540 if (!old_desc
&& old
->commit
)
541 old_desc
= sha1_to_hex(old
->commit
->object
.sha1
);
542 strbuf_addf(&msg
, "checkout: moving from %s to %s",
543 old_desc
? old_desc
: "(invalid)", new->name
);
546 create_symref("HEAD", new->path
, msg
.buf
);
548 if (old
->path
&& !strcmp(new->path
, old
->path
))
549 fprintf(stderr
, "Already on '%s'\n",
551 else if (opts
->new_branch
)
552 fprintf(stderr
, "Switched to%s branch '%s'\n",
553 opts
->branch_exists
? " and reset" : " a new",
556 fprintf(stderr
, "Switched to branch '%s'\n",
559 if (old
->path
&& old
->name
) {
560 char log_file
[PATH_MAX
], ref_file
[PATH_MAX
];
562 git_snpath(log_file
, sizeof(log_file
), "logs/%s", old
->path
);
563 git_snpath(ref_file
, sizeof(ref_file
), "%s", old
->path
);
564 if (!file_exists(ref_file
) && file_exists(log_file
))
565 remove_path(log_file
);
567 } else if (opts
->force_detach
|| strcmp(new->name
, "HEAD")) {
568 update_ref(msg
.buf
, "HEAD", new->commit
->object
.sha1
, NULL
,
569 REF_NODEREF
, DIE_ON_ERR
);
571 if (old
->path
&& advice_detached_head
)
572 detach_advice(old
->path
, new->name
);
573 describe_detached_head("HEAD is now at", new->commit
);
576 remove_branch_state();
577 strbuf_release(&msg
);
579 (new->path
|| (!opts
->force_detach
&& !strcmp(new->name
, "HEAD"))))
580 report_tracking(new);
583 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
586 struct branch_info old
;
587 unsigned char rev
[20];
589 memset(&old
, 0, sizeof(old
));
590 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
591 old
.commit
= lookup_commit_reference_gently(rev
, 1);
592 if (!(flag
& REF_ISSYMREF
))
595 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
596 old
.name
= old
.path
+ strlen("refs/heads/");
600 new->commit
= old
.commit
;
602 die("You are on a branch yet to be born");
603 parse_commit(new->commit
);
606 ret
= merge_working_tree(opts
, &old
, new);
611 * If we were on a detached HEAD, but have now moved to
612 * a new commit, we want to mention the old commit once more
613 * to remind the user that it might be lost.
615 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
616 describe_detached_head("Previous HEAD position was", old
.commit
);
618 update_refs_for_switch(opts
, &old
, new);
620 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
621 return ret
|| opts
->writeout_error
;
624 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
626 if (!strcmp(var
, "diff.ignoresubmodules")) {
627 struct checkout_opts
*opts
= cb
;
628 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
632 if (!prefixcmp(var
, "submodule."))
633 return parse_submodule_config_option(var
, value
);
635 return git_xmerge_config(var
, value
, NULL
);
638 static int interactive_checkout(const char *revision
, const char **pathspec
,
639 struct checkout_opts
*opts
)
641 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
644 struct tracking_name_data
{
650 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
651 int flags
, void *cb_data
)
653 struct tracking_name_data
*cb
= cb_data
;
656 if (prefixcmp(refname
, "refs/remotes/"))
658 slash
= strchr(refname
+ 13, '/');
659 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
665 cb
->remote
= xstrdup(refname
);
669 static const char *unique_tracking_name(const char *name
)
671 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
673 for_each_ref(check_tracking_name
, &cb_data
);
675 return cb_data
.remote
;
676 free(cb_data
.remote
);
680 static int parse_branchname_arg(int argc
, const char **argv
,
681 int dwim_new_local_branch_ok
,
683 struct branch_info
*new,
684 struct tree
**source_tree
,
685 unsigned char rev
[20],
686 const char **new_branch
)
689 unsigned char branch_rev
[20];
694 * case 1: git checkout <ref> -- [<paths>]
696 * <ref> must be a valid tree, everything after the '--' must be
699 * case 2: git checkout -- [<paths>]
701 * everything after the '--' must be paths.
703 * case 3: git checkout <something> [<paths>]
705 * With no paths, if <something> is a commit, that is to
706 * switch to the branch or detach HEAD at it. As a special case,
707 * if <something> is A...B (missing A or B means HEAD but you can
708 * omit at most one side), and if there is a unique merge base
709 * between A and B, A...B names that merge base.
711 * With no paths, if <something> is _not_ a commit, no -t nor -b
712 * was given, and there is a tracking branch whose name is
713 * <something> in one and only one remote, then this is a short-hand
714 * to fork local <something> from that remote tracking branch.
716 * Otherwise <something> shall not be ambiguous.
717 * - If it's *only* a reference, treat it like case (1).
718 * - If it's only a path, treat it like case (2).
725 if (!strcmp(argv
[0], "--")) /* case (2) */
729 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
731 if (!strcmp(arg
, "-"))
734 if (get_sha1_mb(arg
, rev
)) {
735 if (has_dash_dash
) /* case (1) */
736 die("invalid reference: %s", arg
);
737 if (dwim_new_local_branch_ok
&&
738 !check_filename(NULL
, arg
) &&
740 const char *remote
= unique_tracking_name(arg
);
741 if (!remote
|| get_sha1(remote
, rev
))
745 /* DWIMmed to create local branch */
751 /* we can't end up being in (2) anymore, eat the argument */
757 setup_branch_path(new);
760 check_ref_format(new->path
) == CHECK_REF_FORMAT_OK
&&
761 resolve_ref(new->path
, branch_rev
, 1, NULL
))
762 hashcpy(rev
, branch_rev
);
764 new->path
= NULL
; /* not an existing branch */
766 new->commit
= lookup_commit_reference_gently(rev
, 1);
769 *source_tree
= parse_tree_indirect(rev
);
771 parse_commit(new->commit
);
772 *source_tree
= new->commit
->tree
;
775 if (!*source_tree
) /* case (1): want a tree */
776 die("reference is not a tree: %s", arg
);
777 if (!has_dash_dash
) {/* case (3 -> 1) */
779 * Do not complain the most common case
780 * git checkout branch
781 * even if there happen to be a file called 'branch';
782 * it would be extremely annoying.
785 verify_non_filename(NULL
, arg
);
795 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
797 struct checkout_opts opts
;
798 unsigned char rev
[20];
799 struct branch_info
new;
800 struct tree
*source_tree
= NULL
;
801 char *conflict_style
= NULL
;
803 int dwim_new_local_branch
= 1;
804 struct option options
[] = {
805 OPT__QUIET(&opts
.quiet
),
806 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
807 "create and checkout a new branch"),
808 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
809 "create/reset and checkout a branch"),
810 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "create reflog for new branch"),
811 OPT_BOOLEAN(0, "detach", &opts
.force_detach
, "detach the HEAD at named commit"),
812 OPT_SET_INT('t', "track", &opts
.track
, "set upstream info for new branch",
813 BRANCH_TRACK_EXPLICIT
),
814 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
815 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "checkout our version for unmerged files",
817 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "checkout their version for unmerged files",
819 OPT_BOOLEAN('f', "force", &opts
.force
, "force checkout (throw away local modifications)"),
820 OPT_BOOLEAN('m', "merge", &opts
.merge
, "perform a 3-way merge with the new branch"),
821 OPT_STRING(0, "conflict", &conflict_style
, "style",
822 "conflict style (merge or diff3)"),
823 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
824 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
825 "second guess 'git checkout no-such-branch'",
826 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
830 memset(&opts
, 0, sizeof(opts
));
831 memset(&new, 0, sizeof(new));
834 git_config(git_checkout_config
, &opts
);
836 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
838 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
839 PARSE_OPT_KEEP_DASHDASH
);
841 /* we can assume from now on new_branch = !new_branch_force */
842 if (opts
.new_branch
&& opts
.new_branch_force
)
843 die("-B cannot be used with -b");
845 /* copy -B over to -b, so that we can just check the latter */
846 if (opts
.new_branch_force
)
847 opts
.new_branch
= opts
.new_branch_force
;
849 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
850 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
851 || opts
.force_detach
))
852 die ("--patch is incompatible with all other options");
854 if (opts
.force_detach
&& (opts
.new_branch
|| opts
.new_orphan_branch
))
855 die("--detach cannot be used with -b/-B/--orphan");
856 if (opts
.force_detach
&& 0 < opts
.track
)
857 die("--detach cannot be used with -t");
859 /* --track without -b should DWIM */
860 if (0 < opts
.track
&& !opts
.new_branch
) {
861 const char *argv0
= argv
[0];
862 if (!argc
|| !strcmp(argv0
, "--"))
863 die ("--track needs a branch name");
864 if (!prefixcmp(argv0
, "refs/"))
866 if (!prefixcmp(argv0
, "remotes/"))
868 argv0
= strchr(argv0
, '/');
869 if (!argv0
|| !argv0
[1])
870 die ("Missing branch name; try -b");
871 opts
.new_branch
= argv0
+ 1;
874 if (opts
.new_orphan_branch
) {
876 die("--orphan and -b|-B are mutually exclusive");
878 die("--orphan cannot be used with -t");
879 opts
.new_branch
= opts
.new_orphan_branch
;
882 if (conflict_style
) {
883 opts
.merge
= 1; /* implied */
884 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
887 if (opts
.force
&& opts
.merge
)
888 die("git checkout: -f and -m are incompatible");
891 * Extract branch name from command line arguments, so
892 * all that is left is pathspecs.
896 * 1) git checkout <tree> -- [<paths>]
897 * 2) git checkout -- [<paths>]
898 * 3) git checkout <something> [<paths>]
900 * including "last branch" syntax and DWIM-ery for names of
901 * remote branches, erroring out for invalid or ambiguous cases.
906 dwim_new_local_branch
&&
907 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
909 int n
= parse_branchname_arg(argc
, argv
,
910 dwim_ok
, opts
.force_detach
,
911 &new, &source_tree
, rev
, &opts
.new_branch
);
916 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
917 opts
.track
= git_branch_track
;
920 const char **pathspec
= get_pathspec(prefix
, argv
);
923 die("invalid path specification");
926 return interactive_checkout(new.name
, pathspec
, &opts
);
929 if (opts
.new_branch
) {
931 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]);
933 die("git checkout: updating paths is incompatible with switching branches.");
937 if (opts
.force_detach
)
938 die("git checkout: --detach does not take a path argument");
940 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
941 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
943 return checkout_paths(source_tree
, pathspec
, &opts
);
947 return interactive_checkout(new.name
, NULL
, &opts
);
949 if (opts
.new_branch
) {
950 struct strbuf buf
= STRBUF_INIT
;
951 if (strbuf_check_branch_ref(&buf
, opts
.new_branch
))
952 die("git checkout: we do not like '%s' as a branch name.",
954 if (!get_sha1(buf
.buf
, rev
)) {
955 opts
.branch_exists
= 1;
956 if (!opts
.new_branch_force
)
957 die("git checkout: branch %s already exists",
960 strbuf_release(&buf
);
963 if (new.name
&& !new.commit
) {
964 die("Cannot switch branch to a non-commit.");
966 if (opts
.writeout_stage
)
967 die("--ours/--theirs is incompatible with switching branches.");
969 return switch_branches(&opts
, &new);