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 /* not set by parse_options */
38 const char *new_branch
;
39 const char *new_branch_force
;
40 const char *new_orphan_branch
;
42 enum branch_track track
;
45 static int post_checkout_hook(struct commit
*old
, struct commit
*new,
48 return run_hook(NULL
, "post-checkout",
49 sha1_to_hex(old
? old
->object
.sha1
: null_sha1
),
50 sha1_to_hex(new ? new->object
.sha1
: null_sha1
),
51 changed
? "1" : "0", NULL
);
52 /* "new" can be NULL when checking out from the index before
57 static int update_some(const unsigned char *sha1
, const char *base
, int baselen
,
58 const char *pathname
, unsigned mode
, int stage
, void *context
)
61 struct cache_entry
*ce
;
64 return READ_TREE_RECURSIVE
;
66 len
= baselen
+ strlen(pathname
);
67 ce
= xcalloc(1, cache_entry_size(len
));
68 hashcpy(ce
->sha1
, sha1
);
69 memcpy(ce
->name
, base
, baselen
);
70 memcpy(ce
->name
+ baselen
, pathname
, len
- baselen
);
71 ce
->ce_flags
= create_ce_flags(len
, 0);
72 ce
->ce_mode
= create_ce_mode(mode
);
73 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
77 static int read_tree_some(struct tree
*tree
, const char **pathspec
)
79 read_tree_recursive(tree
, "", 0, 0, pathspec
, update_some
, NULL
);
81 /* update the index with the given tree's info
82 * for all args, expanding wildcards, and exit
83 * with any non-zero return code.
88 static int skip_same_name(struct cache_entry
*ce
, int pos
)
90 while (++pos
< active_nr
&&
91 !strcmp(active_cache
[pos
]->name
, ce
->name
))
96 static int check_stage(int stage
, struct cache_entry
*ce
, int pos
)
98 while (pos
< active_nr
&&
99 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
100 if (ce_stage(active_cache
[pos
]) == stage
)
104 return error("path '%s' does not have %s version",
106 (stage
== 2) ? "our" : "their");
109 static int check_all_stages(struct cache_entry
*ce
, int pos
)
111 if (ce_stage(ce
) != 1 ||
112 active_nr
<= pos
+ 2 ||
113 strcmp(active_cache
[pos
+1]->name
, ce
->name
) ||
114 ce_stage(active_cache
[pos
+1]) != 2 ||
115 strcmp(active_cache
[pos
+2]->name
, ce
->name
) ||
116 ce_stage(active_cache
[pos
+2]) != 3)
117 return error("path '%s' does not have all three versions",
122 static int checkout_stage(int stage
, struct cache_entry
*ce
, int pos
,
123 struct checkout
*state
)
125 while (pos
< active_nr
&&
126 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
127 if (ce_stage(active_cache
[pos
]) == stage
)
128 return checkout_entry(active_cache
[pos
], state
, NULL
);
131 return error("path '%s' does not have %s version",
133 (stage
== 2) ? "our" : "their");
136 static int checkout_merged(int pos
, struct checkout
*state
)
138 struct cache_entry
*ce
= active_cache
[pos
];
139 const char *path
= ce
->name
;
140 mmfile_t ancestor
, ours
, theirs
;
142 unsigned char sha1
[20];
143 mmbuffer_t result_buf
;
145 if (ce_stage(ce
) != 1 ||
146 active_nr
<= pos
+ 2 ||
147 strcmp(active_cache
[pos
+1]->name
, path
) ||
148 ce_stage(active_cache
[pos
+1]) != 2 ||
149 strcmp(active_cache
[pos
+2]->name
, path
) ||
150 ce_stage(active_cache
[pos
+2]) != 3)
151 return error("path '%s' does not have all 3 versions", path
);
153 read_mmblob(&ancestor
, active_cache
[pos
]->sha1
);
154 read_mmblob(&ours
, active_cache
[pos
+1]->sha1
);
155 read_mmblob(&theirs
, active_cache
[pos
+2]->sha1
);
158 * NEEDSWORK: re-create conflicts from merges with
159 * merge.renormalize set, too
161 status
= ll_merge(&result_buf
, path
, &ancestor
, "base",
162 &ours
, "ours", &theirs
, "theirs", 0);
166 if (status
< 0 || !result_buf
.ptr
) {
167 free(result_buf
.ptr
);
168 return error("path '%s': cannot merge", path
);
173 * There is absolutely no reason to write this as a blob object
174 * and create a phony cache entry just to leak. This hack is
175 * primarily to get to the write_entry() machinery that massages
176 * the contents to work-tree format and writes out which only
177 * allows it for a cache entry. The code in write_entry() needs
178 * to be refactored to allow us to feed a <buffer, size, mode>
179 * instead of a cache entry. Such a refactoring would help
180 * merge_recursive as well (it also writes the merge result to the
181 * object database even when it may contain conflicts).
183 if (write_sha1_file(result_buf
.ptr
, result_buf
.size
,
185 die("Unable to add merge result for '%s'", path
);
186 ce
= make_cache_entry(create_ce_mode(active_cache
[pos
+1]->ce_mode
),
190 die("make_cache_entry failed for path '%s'", path
);
191 status
= checkout_entry(ce
, state
, NULL
);
195 static int checkout_paths(struct tree
*source_tree
, const char **pathspec
,
196 struct checkout_opts
*opts
)
199 struct checkout state
;
200 static char *ps_matched
;
201 unsigned char rev
[20];
205 int stage
= opts
->writeout_stage
;
206 int merge
= opts
->merge
;
208 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
210 newfd
= hold_locked_index(lock_file
, 1);
211 if (read_cache_preload(pathspec
) < 0)
212 return error("corrupt index file");
215 read_tree_some(source_tree
, pathspec
);
217 for (pos
= 0; pathspec
[pos
]; pos
++)
219 ps_matched
= xcalloc(1, pos
);
221 for (pos
= 0; pos
< active_nr
; pos
++) {
222 struct cache_entry
*ce
= active_cache
[pos
];
223 match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, ps_matched
);
226 if (report_path_error(ps_matched
, pathspec
, 0))
229 /* "checkout -m path" to recreate conflicted state */
231 unmerge_cache(pathspec
);
233 /* Any unmerged paths? */
234 for (pos
= 0; pos
< active_nr
; pos
++) {
235 struct cache_entry
*ce
= active_cache
[pos
];
236 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
240 warning("path '%s' is unmerged", ce
->name
);
242 errs
|= check_stage(stage
, ce
, pos
);
243 } else if (opts
->merge
) {
244 errs
|= check_all_stages(ce
, pos
);
247 error("path '%s' is unmerged", ce
->name
);
249 pos
= skip_same_name(ce
, pos
) - 1;
255 /* Now we are committed to check them out */
256 memset(&state
, 0, sizeof(state
));
258 state
.refresh_cache
= 1;
259 for (pos
= 0; pos
< active_nr
; pos
++) {
260 struct cache_entry
*ce
= active_cache
[pos
];
261 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
263 errs
|= checkout_entry(ce
, &state
, NULL
);
267 errs
|= checkout_stage(stage
, ce
, pos
, &state
);
269 errs
|= checkout_merged(pos
, &state
);
270 pos
= skip_same_name(ce
, pos
) - 1;
274 if (write_cache(newfd
, active_cache
, active_nr
) ||
275 commit_locked_index(lock_file
))
276 die("unable to write new index file");
278 resolve_ref("HEAD", rev
, 0, &flag
);
279 head
= lookup_commit_reference_gently(rev
, 1);
281 errs
|= post_checkout_hook(head
, head
, 0);
285 static void show_local_changes(struct object
*head
)
288 /* I think we want full paths, even if we're in a subdirectory. */
289 init_revisions(&rev
, NULL
);
290 rev
.diffopt
.output_format
|= DIFF_FORMAT_NAME_STATUS
;
291 if (diff_setup_done(&rev
.diffopt
) < 0)
292 die("diff_setup_done failed");
293 add_pending_object(&rev
, head
, NULL
);
294 run_diff_index(&rev
, 0);
297 static void describe_detached_head(char *msg
, struct commit
*commit
)
299 struct strbuf sb
= STRBUF_INIT
;
300 struct pretty_print_context ctx
= {0};
301 parse_commit(commit
);
302 pretty_print_commit(CMIT_FMT_ONELINE
, commit
, &sb
, &ctx
);
303 fprintf(stderr
, "%s %s... %s\n", msg
,
304 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
308 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
310 struct unpack_trees_options opts
;
311 struct tree_desc tree_desc
;
313 memset(&opts
, 0, sizeof(opts
));
315 opts
.update
= worktree
;
316 opts
.skip_unmerged
= !worktree
;
319 opts
.fn
= oneway_merge
;
320 opts
.verbose_update
= !o
->quiet
;
321 opts
.src_index
= &the_index
;
322 opts
.dst_index
= &the_index
;
324 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
325 switch (unpack_trees(1, &tree_desc
, &opts
)) {
327 o
->writeout_error
= 1;
329 * We return 0 nevertheless, as the index is all right
330 * and more importantly we have made best efforts to
331 * update paths in the work tree, and we cannot revert
342 const char *name
; /* The short name used */
343 const char *path
; /* The full name of a real branch */
344 struct commit
*commit
; /* The named commit */
347 static void setup_branch_path(struct branch_info
*branch
)
349 struct strbuf buf
= STRBUF_INIT
;
351 strbuf_branchname(&buf
, branch
->name
);
352 if (strcmp(buf
.buf
, branch
->name
))
353 branch
->name
= xstrdup(buf
.buf
);
354 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
355 branch
->path
= strbuf_detach(&buf
, NULL
);
358 static int merge_working_tree(struct checkout_opts
*opts
,
359 struct branch_info
*old
, struct branch_info
*new)
362 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
363 int newfd
= hold_locked_index(lock_file
, 1);
365 if (read_cache_preload(NULL
) < 0)
366 return error("corrupt index file");
368 resolve_undo_clear();
370 ret
= reset_tree(new->commit
->tree
, opts
, 1);
374 struct tree_desc trees
[2];
376 struct unpack_trees_options topts
;
378 memset(&topts
, 0, sizeof(topts
));
380 topts
.src_index
= &the_index
;
381 topts
.dst_index
= &the_index
;
383 setup_unpack_trees_porcelain(&topts
, "checkout");
385 refresh_cache(REFRESH_QUIET
);
387 if (unmerged_cache()) {
388 error("you need to resolve your current index first");
392 /* 2-way merge to the new branch */
393 topts
.initial_checkout
= is_cache_unborn();
396 topts
.gently
= opts
->merge
&& old
->commit
;
397 topts
.verbose_update
= !opts
->quiet
;
398 topts
.fn
= twoway_merge
;
399 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
400 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
401 topts
.dir
->exclude_per_dir
= ".gitignore";
402 tree
= parse_tree_indirect(old
->commit
?
403 old
->commit
->object
.sha1
:
404 (unsigned char *)EMPTY_TREE_SHA1_BIN
);
405 init_tree_desc(&trees
[0], tree
->buffer
, tree
->size
);
406 tree
= parse_tree_indirect(new->commit
->object
.sha1
);
407 init_tree_desc(&trees
[1], tree
->buffer
, tree
->size
);
409 ret
= unpack_trees(2, trees
, &topts
);
412 * Unpack couldn't do a trivial merge; either
413 * give up or do a real merge, depending on
414 * whether the merge flag was used.
418 struct merge_options o
;
423 * Without old->commit, the below is the same as
424 * the two-tree unpack we already tried and failed.
429 /* Do more real merge */
432 * We update the index fully, then write the
433 * tree from the index, then merge the new
434 * branch with the current tree, with the old
435 * branch as the base. Then we reset the index
436 * (but not the working tree) to the new
437 * branch, leaving the working tree as the
438 * merged version, but skipping unmerged
439 * entries in the index.
442 add_files_to_cache(NULL
, NULL
, 0);
444 * NEEDSWORK: carrying over local changes
445 * when branches have different end-of-line
446 * normalization (or clean+smudge rules) is
447 * a pain; plumb in an option to set
450 init_merge_options(&o
);
452 work
= write_tree_from_memory(&o
);
454 ret
= reset_tree(new->commit
->tree
, opts
, 1);
457 o
.ancestor
= old
->name
;
458 o
.branch1
= new->name
;
460 merge_trees(&o
, new->commit
->tree
, work
,
461 old
->commit
->tree
, &result
);
462 ret
= reset_tree(new->commit
->tree
, opts
, 0);
468 if (write_cache(newfd
, active_cache
, active_nr
) ||
469 commit_locked_index(lock_file
))
470 die("unable to write new index file");
472 if (!opts
->force
&& !opts
->quiet
)
473 show_local_changes(&new->commit
->object
);
478 static void report_tracking(struct branch_info
*new)
480 struct strbuf sb
= STRBUF_INIT
;
481 struct branch
*branch
= branch_get(new->name
);
483 if (!format_tracking_info(branch
, &sb
))
485 fputs(sb
.buf
, stdout
);
489 static void detach_advice(const char *old_path
, const char *new_name
)
492 "Note: checking out '%s'.\n\n"
493 "You are in 'detached HEAD' state. You can look around, make experimental\n"
494 "changes and commit them, and you can discard any commits you make in this\n"
495 "state without impacting any branches by performing another checkout.\n\n"
496 "If you want to create a new branch to retain commits you create, you may\n"
497 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
498 " git checkout -b new_branch_name\n\n";
500 fprintf(stderr
, fmt
, new_name
);
503 static void update_refs_for_switch(struct checkout_opts
*opts
,
504 struct branch_info
*old
,
505 struct branch_info
*new)
507 struct strbuf msg
= STRBUF_INIT
;
508 const char *old_desc
;
509 if (opts
->new_branch
) {
510 if (opts
->new_orphan_branch
) {
511 if (opts
->new_branch_log
&& !log_all_ref_updates
) {
513 char log_file
[PATH_MAX
];
514 char *ref_name
= mkpath("refs/heads/%s", opts
->new_orphan_branch
);
516 temp
= log_all_ref_updates
;
517 log_all_ref_updates
= 1;
518 if (log_ref_setup(ref_name
, log_file
, sizeof(log_file
))) {
519 fprintf(stderr
, "Can not do reflog for '%s'\n",
520 opts
->new_orphan_branch
);
521 log_all_ref_updates
= temp
;
524 log_all_ref_updates
= temp
;
528 create_branch(old
->name
, opts
->new_branch
, new->name
,
529 opts
->new_branch_force
? 1 : 0,
530 opts
->new_branch_log
, opts
->track
);
531 new->name
= opts
->new_branch
;
532 setup_branch_path(new);
535 old_desc
= old
->name
;
536 if (!old_desc
&& old
->commit
)
537 old_desc
= sha1_to_hex(old
->commit
->object
.sha1
);
538 strbuf_addf(&msg
, "checkout: moving from %s to %s",
539 old_desc
? old_desc
: "(invalid)", new->name
);
542 create_symref("HEAD", new->path
, msg
.buf
);
544 if (old
->path
&& !strcmp(new->path
, old
->path
))
545 fprintf(stderr
, "Already on '%s'\n",
547 else if (opts
->new_branch
)
548 fprintf(stderr
, "Switched to%s branch '%s'\n",
549 opts
->branch_exists
? " and reset" : " a new",
552 fprintf(stderr
, "Switched to branch '%s'\n",
555 if (old
->path
&& old
->name
) {
556 char log_file
[PATH_MAX
], ref_file
[PATH_MAX
];
558 git_snpath(log_file
, sizeof(log_file
), "logs/%s", old
->path
);
559 git_snpath(ref_file
, sizeof(ref_file
), "%s", old
->path
);
560 if (!file_exists(ref_file
) && file_exists(log_file
))
561 remove_path(log_file
);
563 } else if (strcmp(new->name
, "HEAD")) {
564 update_ref(msg
.buf
, "HEAD", new->commit
->object
.sha1
, NULL
,
565 REF_NODEREF
, DIE_ON_ERR
);
567 if (old
->path
&& advice_detached_head
)
568 detach_advice(old
->path
, new->name
);
569 describe_detached_head("HEAD is now at", new->commit
);
572 remove_branch_state();
573 strbuf_release(&msg
);
574 if (!opts
->quiet
&& (new->path
|| !strcmp(new->name
, "HEAD")))
575 report_tracking(new);
578 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
581 struct branch_info old
;
582 unsigned char rev
[20];
584 memset(&old
, 0, sizeof(old
));
585 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
586 old
.commit
= lookup_commit_reference_gently(rev
, 1);
587 if (!(flag
& REF_ISSYMREF
))
590 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
591 old
.name
= old
.path
+ strlen("refs/heads/");
595 new->commit
= old
.commit
;
597 die("You are on a branch yet to be born");
598 parse_commit(new->commit
);
601 ret
= merge_working_tree(opts
, &old
, new);
606 * If we were on a detached HEAD, but have now moved to
607 * a new commit, we want to mention the old commit once more
608 * to remind the user that it might be lost.
610 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
611 describe_detached_head("Previous HEAD position was", old
.commit
);
613 update_refs_for_switch(opts
, &old
, new);
615 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
616 return ret
|| opts
->writeout_error
;
619 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
621 return git_xmerge_config(var
, value
, cb
);
624 static int interactive_checkout(const char *revision
, const char **pathspec
,
625 struct checkout_opts
*opts
)
627 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
630 struct tracking_name_data
{
636 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
637 int flags
, void *cb_data
)
639 struct tracking_name_data
*cb
= cb_data
;
642 if (prefixcmp(refname
, "refs/remotes/"))
644 slash
= strchr(refname
+ 13, '/');
645 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
651 cb
->remote
= xstrdup(refname
);
655 static const char *unique_tracking_name(const char *name
)
657 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
659 for_each_ref(check_tracking_name
, &cb_data
);
661 return cb_data
.remote
;
662 free(cb_data
.remote
);
666 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
668 struct checkout_opts opts
;
669 unsigned char rev
[20];
671 struct branch_info
new;
672 struct tree
*source_tree
= NULL
;
673 char *conflict_style
= NULL
;
675 int dwim_new_local_branch
= 1;
676 struct option options
[] = {
677 OPT__QUIET(&opts
.quiet
),
678 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
679 "create and checkout a new branch"),
680 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
681 "create/reset and checkout a branch"),
682 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "log for new branch"),
683 OPT_SET_INT('t', "track", &opts
.track
, "track",
684 BRANCH_TRACK_EXPLICIT
),
685 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
686 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "stage",
688 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "stage",
690 OPT_BOOLEAN('f', "force", &opts
.force
, "force"),
691 OPT_BOOLEAN('m', "merge", &opts
.merge
, "merge"),
692 OPT_STRING(0, "conflict", &conflict_style
, "style",
693 "conflict style (merge or diff3)"),
694 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
695 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
696 "second guess 'git checkout no-such-branch'",
697 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
702 memset(&opts
, 0, sizeof(opts
));
703 memset(&new, 0, sizeof(new));
705 git_config(git_checkout_config
, NULL
);
707 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
709 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
710 PARSE_OPT_KEEP_DASHDASH
);
712 /* we can assume from now on new_branch = !new_branch_force */
713 if (opts
.new_branch
&& opts
.new_branch_force
)
714 die("-B cannot be used with -b");
716 /* copy -B over to -b, so that we can just check the latter */
717 if (opts
.new_branch_force
)
718 opts
.new_branch
= opts
.new_branch_force
;
720 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
721 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
))
722 die ("--patch is incompatible with all other options");
724 /* --track without -b should DWIM */
725 if (0 < opts
.track
&& !opts
.new_branch
) {
726 const char *argv0
= argv
[0];
727 if (!argc
|| !strcmp(argv0
, "--"))
728 die ("--track needs a branch name");
729 if (!prefixcmp(argv0
, "refs/"))
731 if (!prefixcmp(argv0
, "remotes/"))
733 argv0
= strchr(argv0
, '/');
734 if (!argv0
|| !argv0
[1])
735 die ("Missing branch name; try -b");
736 opts
.new_branch
= argv0
+ 1;
739 if (opts
.new_orphan_branch
) {
741 die("--orphan and -b|-B are mutually exclusive");
743 die("--orphan cannot be used with -t");
744 opts
.new_branch
= opts
.new_orphan_branch
;
747 if (conflict_style
) {
748 opts
.merge
= 1; /* implied */
749 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
752 if (opts
.force
&& opts
.merge
)
753 die("git checkout: -f and -m are incompatible");
756 * case 1: git checkout <ref> -- [<paths>]
758 * <ref> must be a valid tree, everything after the '--' must be
761 * case 2: git checkout -- [<paths>]
763 * everything after the '--' must be paths.
765 * case 3: git checkout <something> [<paths>]
767 * With no paths, if <something> is a commit, that is to
768 * switch to the branch or detach HEAD at it. As a special case,
769 * if <something> is A...B (missing A or B means HEAD but you can
770 * omit at most one side), and if there is a unique merge base
771 * between A and B, A...B names that merge base.
773 * With no paths, if <something> is _not_ a commit, no -t nor -b
774 * was given, and there is a tracking branch whose name is
775 * <something> in one and only one remote, then this is a short-hand
776 * to fork local <something> from that remote tracking branch.
778 * Otherwise <something> shall not be ambiguous.
779 * - If it's *only* a reference, treat it like case (1).
780 * - If it's only a path, treat it like case (2).
785 if (!strcmp(argv
[0], "--")) { /* case (2) */
792 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
794 if (!strcmp(arg
, "-"))
797 if (get_sha1_mb(arg
, rev
)) {
798 if (has_dash_dash
) /* case (1) */
799 die("invalid reference: %s", arg
);
801 dwim_new_local_branch
&&
802 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
804 !check_filename(NULL
, arg
) &&
806 const char *remote
= unique_tracking_name(arg
);
807 if (!remote
|| get_sha1(remote
, rev
))
809 opts
.new_branch
= arg
;
811 /* DWIMmed to create local branch */
817 /* we can't end up being in (2) anymore, eat the argument */
822 if ((new.commit
= lookup_commit_reference_gently(rev
, 1))) {
823 setup_branch_path(&new);
825 if ((check_ref_format(new.path
) == CHECK_REF_FORMAT_OK
) &&
826 resolve_ref(new.path
, rev
, 1, NULL
))
830 parse_commit(new.commit
);
831 source_tree
= new.commit
->tree
;
833 source_tree
= parse_tree_indirect(rev
);
835 if (!source_tree
) /* case (1): want a tree */
836 die("reference is not a tree: %s", arg
);
837 if (!has_dash_dash
) {/* case (3 -> 1) */
839 * Do not complain the most common case
840 * git checkout branch
841 * even if there happen to be a file called 'branch';
842 * it would be extremely annoying.
845 verify_non_filename(NULL
, arg
);
855 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
856 opts
.track
= git_branch_track
;
859 const char **pathspec
= get_pathspec(prefix
, argv
);
862 die("invalid path specification");
865 return interactive_checkout(new.name
, pathspec
, &opts
);
868 if (opts
.new_branch
) {
870 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]);
872 die("git checkout: updating paths is incompatible with switching branches.");
876 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
877 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
879 return checkout_paths(source_tree
, pathspec
, &opts
);
883 return interactive_checkout(new.name
, NULL
, &opts
);
885 if (opts
.new_branch
) {
886 struct strbuf buf
= STRBUF_INIT
;
887 if (strbuf_check_branch_ref(&buf
, opts
.new_branch
))
888 die("git checkout: we do not like '%s' as a branch name.",
890 if (!get_sha1(buf
.buf
, rev
)) {
891 opts
.branch_exists
= 1;
892 if (!opts
.new_branch_force
)
893 die("git checkout: branch %s already exists",
896 strbuf_release(&buf
);
899 if (new.name
&& !new.commit
) {
900 die("Cannot switch branch to a non-commit.");
902 if (opts
.writeout_stage
)
903 die("--ours/--theirs is incompatible with switching branches.");
905 return switch_branches(&opts
, &new);