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
{
36 const char *new_branch
;
37 const char *new_orphan_branch
;
39 enum branch_track track
;
40 struct diff_options diff_options
;
43 static int post_checkout_hook(struct commit
*old
, struct commit
*new,
46 return run_hook(NULL
, "post-checkout",
47 sha1_to_hex(old
? old
->object
.sha1
: null_sha1
),
48 sha1_to_hex(new ? new->object
.sha1
: null_sha1
),
49 changed
? "1" : "0", NULL
);
50 /* "new" can be NULL when checking out from the index before
55 static int update_some(const unsigned char *sha1
, const char *base
, int baselen
,
56 const char *pathname
, unsigned mode
, int stage
, void *context
)
59 struct cache_entry
*ce
;
62 return READ_TREE_RECURSIVE
;
64 len
= baselen
+ strlen(pathname
);
65 ce
= xcalloc(1, cache_entry_size(len
));
66 hashcpy(ce
->sha1
, sha1
);
67 memcpy(ce
->name
, base
, baselen
);
68 memcpy(ce
->name
+ baselen
, pathname
, len
- baselen
);
69 ce
->ce_flags
= create_ce_flags(len
, 0);
70 ce
->ce_mode
= create_ce_mode(mode
);
71 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
75 static int read_tree_some(struct tree
*tree
, const char **pathspec
)
77 read_tree_recursive(tree
, "", 0, 0, pathspec
, update_some
, NULL
);
79 /* update the index with the given tree's info
80 * for all args, expanding wildcards, and exit
81 * with any non-zero return code.
86 static int skip_same_name(struct cache_entry
*ce
, int pos
)
88 while (++pos
< active_nr
&&
89 !strcmp(active_cache
[pos
]->name
, ce
->name
))
94 static int check_stage(int stage
, struct cache_entry
*ce
, int pos
)
96 while (pos
< active_nr
&&
97 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
98 if (ce_stage(active_cache
[pos
]) == stage
)
102 return error("path '%s' does not have %s version",
104 (stage
== 2) ? "our" : "their");
107 static int check_all_stages(struct cache_entry
*ce
, int pos
)
109 if (ce_stage(ce
) != 1 ||
110 active_nr
<= pos
+ 2 ||
111 strcmp(active_cache
[pos
+1]->name
, ce
->name
) ||
112 ce_stage(active_cache
[pos
+1]) != 2 ||
113 strcmp(active_cache
[pos
+2]->name
, ce
->name
) ||
114 ce_stage(active_cache
[pos
+2]) != 3)
115 return error("path '%s' does not have all three versions",
120 static int checkout_stage(int stage
, struct cache_entry
*ce
, int pos
,
121 struct checkout
*state
)
123 while (pos
< active_nr
&&
124 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
125 if (ce_stage(active_cache
[pos
]) == stage
)
126 return checkout_entry(active_cache
[pos
], state
, NULL
);
129 return error("path '%s' does not have %s version",
131 (stage
== 2) ? "our" : "their");
134 static int checkout_merged(int pos
, struct checkout
*state
)
136 struct cache_entry
*ce
= active_cache
[pos
];
137 const char *path
= ce
->name
;
138 mmfile_t ancestor
, ours
, theirs
;
140 unsigned char sha1
[20];
141 mmbuffer_t result_buf
;
143 if (ce_stage(ce
) != 1 ||
144 active_nr
<= pos
+ 2 ||
145 strcmp(active_cache
[pos
+1]->name
, path
) ||
146 ce_stage(active_cache
[pos
+1]) != 2 ||
147 strcmp(active_cache
[pos
+2]->name
, path
) ||
148 ce_stage(active_cache
[pos
+2]) != 3)
149 return error("path '%s' does not have all 3 versions", path
);
151 read_mmblob(&ancestor
, active_cache
[pos
]->sha1
);
152 read_mmblob(&ours
, active_cache
[pos
+1]->sha1
);
153 read_mmblob(&theirs
, active_cache
[pos
+2]->sha1
);
155 status
= ll_merge(&result_buf
, path
, &ancestor
, "base",
156 &ours
, "ours", &theirs
, "theirs", 0);
160 if (status
< 0 || !result_buf
.ptr
) {
161 free(result_buf
.ptr
);
162 return error("path '%s': cannot merge", path
);
167 * There is absolutely no reason to write this as a blob object
168 * and create a phony cache entry just to leak. This hack is
169 * primarily to get to the write_entry() machinery that massages
170 * the contents to work-tree format and writes out which only
171 * allows it for a cache entry. The code in write_entry() needs
172 * to be refactored to allow us to feed a <buffer, size, mode>
173 * instead of a cache entry. Such a refactoring would help
174 * merge_recursive as well (it also writes the merge result to the
175 * object database even when it may contain conflicts).
177 if (write_sha1_file(result_buf
.ptr
, result_buf
.size
,
179 die("Unable to add merge result for '%s'", path
);
180 ce
= make_cache_entry(create_ce_mode(active_cache
[pos
+1]->ce_mode
),
184 die("make_cache_entry failed for path '%s'", path
);
185 status
= checkout_entry(ce
, state
, NULL
);
189 static int checkout_paths(struct tree
*source_tree
, const char **pathspec
,
190 struct checkout_opts
*opts
)
193 struct checkout state
;
194 static char *ps_matched
;
195 unsigned char rev
[20];
199 int stage
= opts
->writeout_stage
;
200 int merge
= opts
->merge
;
202 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
204 newfd
= hold_locked_index(lock_file
, 1);
205 if (read_cache_preload(pathspec
) < 0)
206 return error("corrupt index file");
209 read_tree_some(source_tree
, pathspec
);
211 for (pos
= 0; pathspec
[pos
]; pos
++)
213 ps_matched
= xcalloc(1, pos
);
215 for (pos
= 0; pos
< active_nr
; pos
++) {
216 struct cache_entry
*ce
= active_cache
[pos
];
217 match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, ps_matched
);
220 if (report_path_error(ps_matched
, pathspec
, 0))
223 /* "checkout -m path" to recreate conflicted state */
225 unmerge_cache(pathspec
);
227 /* Any unmerged paths? */
228 for (pos
= 0; pos
< active_nr
; pos
++) {
229 struct cache_entry
*ce
= active_cache
[pos
];
230 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
234 warning("path '%s' is unmerged", ce
->name
);
236 errs
|= check_stage(stage
, ce
, pos
);
237 } else if (opts
->merge
) {
238 errs
|= check_all_stages(ce
, pos
);
241 error("path '%s' is unmerged", ce
->name
);
243 pos
= skip_same_name(ce
, pos
) - 1;
249 /* Now we are committed to check them out */
250 memset(&state
, 0, sizeof(state
));
252 state
.refresh_cache
= 1;
253 for (pos
= 0; pos
< active_nr
; pos
++) {
254 struct cache_entry
*ce
= active_cache
[pos
];
255 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
257 errs
|= checkout_entry(ce
, &state
, NULL
);
261 errs
|= checkout_stage(stage
, ce
, pos
, &state
);
263 errs
|= checkout_merged(pos
, &state
);
264 pos
= skip_same_name(ce
, pos
) - 1;
268 if (write_cache(newfd
, active_cache
, active_nr
) ||
269 commit_locked_index(lock_file
))
270 die("unable to write new index file");
272 resolve_ref("HEAD", rev
, 0, &flag
);
273 head
= lookup_commit_reference_gently(rev
, 1);
275 errs
|= post_checkout_hook(head
, head
, 0);
279 static void show_local_changes(struct object
*head
, struct diff_options
*opts
)
282 /* I think we want full paths, even if we're in a subdirectory. */
283 init_revisions(&rev
, NULL
);
285 rev
.diffopt
.flags
= opts
->flags
;
286 rev
.diffopt
.output_format
|= DIFF_FORMAT_NAME_STATUS
;
287 if (diff_setup_done(&rev
.diffopt
) < 0)
288 die("diff_setup_done failed");
289 add_pending_object(&rev
, head
, NULL
);
290 run_diff_index(&rev
, 0);
293 static void describe_detached_head(char *msg
, struct commit
*commit
)
295 struct strbuf sb
= STRBUF_INIT
;
296 struct pretty_print_context ctx
= {0};
297 parse_commit(commit
);
298 pretty_print_commit(CMIT_FMT_ONELINE
, commit
, &sb
, &ctx
);
299 fprintf(stderr
, "%s %s... %s\n", msg
,
300 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
304 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
306 struct unpack_trees_options opts
;
307 struct tree_desc tree_desc
;
309 memset(&opts
, 0, sizeof(opts
));
311 opts
.update
= worktree
;
312 opts
.skip_unmerged
= !worktree
;
315 opts
.fn
= oneway_merge
;
316 opts
.verbose_update
= !o
->quiet
;
317 opts
.src_index
= &the_index
;
318 opts
.dst_index
= &the_index
;
320 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
321 switch (unpack_trees(1, &tree_desc
, &opts
)) {
323 o
->writeout_error
= 1;
325 * We return 0 nevertheless, as the index is all right
326 * and more importantly we have made best efforts to
327 * update paths in the work tree, and we cannot revert
338 const char *name
; /* The short name used */
339 const char *path
; /* The full name of a real branch */
340 struct commit
*commit
; /* The named commit */
343 static void setup_branch_path(struct branch_info
*branch
)
345 struct strbuf buf
= STRBUF_INIT
;
347 strbuf_branchname(&buf
, branch
->name
);
348 if (strcmp(buf
.buf
, branch
->name
))
349 branch
->name
= xstrdup(buf
.buf
);
350 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
351 branch
->path
= strbuf_detach(&buf
, NULL
);
354 static int merge_working_tree(struct checkout_opts
*opts
,
355 struct branch_info
*old
, struct branch_info
*new)
358 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
359 int newfd
= hold_locked_index(lock_file
, 1);
361 if (read_cache_preload(NULL
) < 0)
362 return error("corrupt index file");
364 resolve_undo_clear();
366 ret
= reset_tree(new->commit
->tree
, opts
, 1);
370 struct tree_desc trees
[2];
372 struct unpack_trees_options topts
;
374 memset(&topts
, 0, sizeof(topts
));
376 topts
.src_index
= &the_index
;
377 topts
.dst_index
= &the_index
;
379 topts
.msgs
.not_uptodate_file
= "You have local changes to '%s'; cannot switch branches.";
381 refresh_cache(REFRESH_QUIET
);
383 if (unmerged_cache()) {
384 error("you need to resolve your current index first");
388 /* 2-way merge to the new branch */
389 topts
.initial_checkout
= is_cache_unborn();
392 topts
.gently
= opts
->merge
&& old
->commit
;
393 topts
.verbose_update
= !opts
->quiet
;
394 topts
.fn
= twoway_merge
;
395 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
396 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
397 topts
.dir
->exclude_per_dir
= ".gitignore";
398 tree
= parse_tree_indirect(old
->commit
?
399 old
->commit
->object
.sha1
:
400 (unsigned char *)EMPTY_TREE_SHA1_BIN
);
401 init_tree_desc(&trees
[0], tree
->buffer
, tree
->size
);
402 tree
= parse_tree_indirect(new->commit
->object
.sha1
);
403 init_tree_desc(&trees
[1], tree
->buffer
, tree
->size
);
405 ret
= unpack_trees(2, trees
, &topts
);
408 * Unpack couldn't do a trivial merge; either
409 * give up or do a real merge, depending on
410 * whether the merge flag was used.
414 struct merge_options o
;
419 * Without old->commit, the below is the same as
420 * the two-tree unpack we already tried and failed.
425 /* Do more real merge */
428 * We update the index fully, then write the
429 * tree from the index, then merge the new
430 * branch with the current tree, with the old
431 * branch as the base. Then we reset the index
432 * (but not the working tree) to the new
433 * branch, leaving the working tree as the
434 * merged version, but skipping unmerged
435 * entries in the index.
438 add_files_to_cache(NULL
, NULL
, 0);
439 init_merge_options(&o
);
441 work
= write_tree_from_memory(&o
);
443 ret
= reset_tree(new->commit
->tree
, opts
, 1);
446 o
.ancestor
= old
->name
;
447 o
.branch1
= new->name
;
449 merge_trees(&o
, new->commit
->tree
, work
,
450 old
->commit
->tree
, &result
);
451 ret
= reset_tree(new->commit
->tree
, opts
, 0);
457 if (write_cache(newfd
, active_cache
, active_nr
) ||
458 commit_locked_index(lock_file
))
459 die("unable to write new index file");
461 if (!opts
->force
&& !opts
->quiet
)
462 show_local_changes(&new->commit
->object
, &opts
->diff_options
);
467 static void report_tracking(struct branch_info
*new)
469 struct strbuf sb
= STRBUF_INIT
;
470 struct branch
*branch
= branch_get(new->name
);
472 if (!format_tracking_info(branch
, &sb
))
474 fputs(sb
.buf
, stdout
);
478 static void detach_advice(const char *old_path
, const char *new_name
)
481 "Note: checking out '%s'.\n\n"
482 "You are in 'detached HEAD' state. You can look around, make experimental\n"
483 "changes and commit them, and you can discard any commits you make in this\n"
484 "state without impacting any branches by performing another checkout.\n\n"
485 "If you want to create a new branch to retain commits you create, you may\n"
486 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
487 " git checkout -b new_branch_name\n\n";
489 fprintf(stderr
, fmt
, new_name
);
492 static void update_refs_for_switch(struct checkout_opts
*opts
,
493 struct branch_info
*old
,
494 struct branch_info
*new)
496 struct strbuf msg
= STRBUF_INIT
;
497 const char *old_desc
;
498 if (opts
->new_branch
) {
499 if (opts
->new_orphan_branch
) {
500 if (opts
->new_branch_log
&& !log_all_ref_updates
) {
502 char log_file
[PATH_MAX
];
503 char *ref_name
= mkpath("refs/heads/%s", opts
->new_orphan_branch
);
505 temp
= log_all_ref_updates
;
506 log_all_ref_updates
= 1;
507 if (log_ref_setup(ref_name
, log_file
, sizeof(log_file
))) {
508 fprintf(stderr
, "Can not do reflog for '%s'\n",
509 opts
->new_orphan_branch
);
510 log_all_ref_updates
= temp
;
513 log_all_ref_updates
= temp
;
517 create_branch(old
->name
, opts
->new_branch
, new->name
, 0,
518 opts
->new_branch_log
, opts
->track
);
519 new->name
= opts
->new_branch
;
520 setup_branch_path(new);
523 old_desc
= old
->name
;
524 if (!old_desc
&& old
->commit
)
525 old_desc
= sha1_to_hex(old
->commit
->object
.sha1
);
526 strbuf_addf(&msg
, "checkout: moving from %s to %s",
527 old_desc
? old_desc
: "(invalid)", new->name
);
530 create_symref("HEAD", new->path
, msg
.buf
);
532 if (old
->path
&& !strcmp(new->path
, old
->path
))
533 fprintf(stderr
, "Already on '%s'\n",
536 fprintf(stderr
, "Switched to%s branch '%s'\n",
537 opts
->new_branch
? " a new" : "",
540 if (old
->path
&& old
->name
) {
541 char log_file
[PATH_MAX
], ref_file
[PATH_MAX
];
543 git_snpath(log_file
, sizeof(log_file
), "logs/%s", old
->path
);
544 git_snpath(ref_file
, sizeof(ref_file
), "%s", old
->path
);
545 if (!file_exists(ref_file
) && file_exists(log_file
))
546 remove_path(log_file
);
548 } else if (strcmp(new->name
, "HEAD")) {
549 update_ref(msg
.buf
, "HEAD", new->commit
->object
.sha1
, NULL
,
550 REF_NODEREF
, DIE_ON_ERR
);
552 if (old
->path
&& advice_detached_head
)
553 detach_advice(old
->path
, new->name
);
554 describe_detached_head("HEAD is now at", new->commit
);
557 remove_branch_state();
558 strbuf_release(&msg
);
559 if (!opts
->quiet
&& (new->path
|| !strcmp(new->name
, "HEAD")))
560 report_tracking(new);
563 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
566 struct branch_info old
;
567 unsigned char rev
[20];
569 memset(&old
, 0, sizeof(old
));
570 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
571 old
.commit
= lookup_commit_reference_gently(rev
, 1);
572 if (!(flag
& REF_ISSYMREF
))
575 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
576 old
.name
= old
.path
+ strlen("refs/heads/");
580 new->commit
= old
.commit
;
582 die("You are on a branch yet to be born");
583 parse_commit(new->commit
);
586 ret
= merge_working_tree(opts
, &old
, new);
591 * If we were on a detached HEAD, but have now moved to
592 * a new commit, we want to mention the old commit once more
593 * to remind the user that it might be lost.
595 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
596 describe_detached_head("Previous HEAD position was", old
.commit
);
598 update_refs_for_switch(opts
, &old
, new);
600 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
601 return ret
|| opts
->writeout_error
;
604 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
606 if (!strcmp(var
, "diff.ignoresubmodules")) {
607 struct checkout_opts
*opts
= cb
;
608 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
611 return git_xmerge_config(var
, value
, NULL
);
614 static int interactive_checkout(const char *revision
, const char **pathspec
,
615 struct checkout_opts
*opts
)
617 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
620 struct tracking_name_data
{
626 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
627 int flags
, void *cb_data
)
629 struct tracking_name_data
*cb
= cb_data
;
632 if (prefixcmp(refname
, "refs/remotes/"))
634 slash
= strchr(refname
+ 13, '/');
635 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
641 cb
->remote
= xstrdup(refname
);
645 static const char *unique_tracking_name(const char *name
)
647 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
649 for_each_ref(check_tracking_name
, &cb_data
);
651 return cb_data
.remote
;
652 free(cb_data
.remote
);
656 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
658 struct checkout_opts opts
;
659 unsigned char rev
[20];
661 struct branch_info
new;
662 struct tree
*source_tree
= NULL
;
663 char *conflict_style
= NULL
;
665 int dwim_new_local_branch
= 1;
666 struct option options
[] = {
667 OPT__QUIET(&opts
.quiet
),
668 OPT_STRING('b', NULL
, &opts
.new_branch
, "new branch", "branch"),
669 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "log for new branch"),
670 OPT_SET_INT('t', "track", &opts
.track
, "track",
671 BRANCH_TRACK_EXPLICIT
),
672 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
673 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "stage",
675 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "stage",
677 OPT_BOOLEAN('f', "force", &opts
.force
, "force"),
678 OPT_BOOLEAN('m', "merge", &opts
.merge
, "merge"),
679 OPT_STRING(0, "conflict", &conflict_style
, "style",
680 "conflict style (merge or diff3)"),
681 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
682 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
683 "second guess 'git checkout no-such-branch'",
684 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
689 memset(&opts
, 0, sizeof(opts
));
690 memset(&new, 0, sizeof(new));
692 git_config(git_checkout_config
, &opts
);
694 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
696 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
697 PARSE_OPT_KEEP_DASHDASH
);
699 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
700 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
))
701 die ("--patch is incompatible with all other options");
703 /* --track without -b should DWIM */
704 if (0 < opts
.track
&& !opts
.new_branch
) {
705 const char *argv0
= argv
[0];
706 if (!argc
|| !strcmp(argv0
, "--"))
707 die ("--track needs a branch name");
708 if (!prefixcmp(argv0
, "refs/"))
710 if (!prefixcmp(argv0
, "remotes/"))
712 argv0
= strchr(argv0
, '/');
713 if (!argv0
|| !argv0
[1])
714 die ("Missing branch name; try -b");
715 opts
.new_branch
= argv0
+ 1;
718 if (opts
.new_orphan_branch
) {
720 die("--orphan and -b are mutually exclusive");
722 die("--orphan cannot be used with -t");
723 opts
.new_branch
= opts
.new_orphan_branch
;
726 if (conflict_style
) {
727 opts
.merge
= 1; /* implied */
728 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
731 if (opts
.force
&& opts
.merge
)
732 die("git checkout: -f and -m are incompatible");
735 * case 1: git checkout <ref> -- [<paths>]
737 * <ref> must be a valid tree, everything after the '--' must be
740 * case 2: git checkout -- [<paths>]
742 * everything after the '--' must be paths.
744 * case 3: git checkout <something> [<paths>]
746 * With no paths, if <something> is a commit, that is to
747 * switch to the branch or detach HEAD at it. As a special case,
748 * if <something> is A...B (missing A or B means HEAD but you can
749 * omit at most one side), and if there is a unique merge base
750 * between A and B, A...B names that merge base.
752 * With no paths, if <something> is _not_ a commit, no -t nor -b
753 * was given, and there is a tracking branch whose name is
754 * <something> in one and only one remote, then this is a short-hand
755 * to fork local <something> from that remote tracking branch.
757 * Otherwise <something> shall not be ambiguous.
758 * - If it's *only* a reference, treat it like case (1).
759 * - If it's only a path, treat it like case (2).
764 if (!strcmp(argv
[0], "--")) { /* case (2) */
771 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
773 if (!strcmp(arg
, "-"))
776 if (get_sha1_mb(arg
, rev
)) {
777 if (has_dash_dash
) /* case (1) */
778 die("invalid reference: %s", arg
);
780 dwim_new_local_branch
&&
781 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
783 !check_filename(NULL
, arg
) &&
785 const char *remote
= unique_tracking_name(arg
);
786 if (!remote
|| get_sha1(remote
, rev
))
788 opts
.new_branch
= arg
;
790 /* DWIMmed to create local branch */
796 /* we can't end up being in (2) anymore, eat the argument */
801 if ((new.commit
= lookup_commit_reference_gently(rev
, 1))) {
802 setup_branch_path(&new);
804 if ((check_ref_format(new.path
) == CHECK_REF_FORMAT_OK
) &&
805 resolve_ref(new.path
, rev
, 1, NULL
))
809 parse_commit(new.commit
);
810 source_tree
= new.commit
->tree
;
812 source_tree
= parse_tree_indirect(rev
);
814 if (!source_tree
) /* case (1): want a tree */
815 die("reference is not a tree: %s", arg
);
816 if (!has_dash_dash
) {/* case (3 -> 1) */
818 * Do not complain the most common case
819 * git checkout branch
820 * even if there happen to be a file called 'branch';
821 * it would be extremely annoying.
824 verify_non_filename(NULL
, arg
);
834 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
835 opts
.track
= git_branch_track
;
838 const char **pathspec
= get_pathspec(prefix
, argv
);
841 die("invalid path specification");
844 return interactive_checkout(new.name
, pathspec
, &opts
);
847 if (opts
.new_branch
) {
849 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]);
851 die("git checkout: updating paths is incompatible with switching branches.");
855 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
856 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
858 return checkout_paths(source_tree
, pathspec
, &opts
);
862 return interactive_checkout(new.name
, NULL
, &opts
);
864 if (opts
.new_branch
) {
865 struct strbuf buf
= STRBUF_INIT
;
866 if (strbuf_check_branch_ref(&buf
, opts
.new_branch
))
867 die("git checkout: we do not like '%s' as a branch name.",
869 if (!get_sha1(buf
.buf
, rev
))
870 die("git checkout: branch %s already exists", opts
.new_branch
);
871 strbuf_release(&buf
);
874 if (new.name
&& !new.commit
) {
875 die("Cannot switch branch to a non-commit.");
877 if (opts
.writeout_stage
)
878 die("--ours/--theirs is incompatible with switching branches.");
880 return switch_branches(&opts
, &new);