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 /* not set by parse_options */
39 const char *new_branch
;
40 const char *new_branch_force
;
41 const char *new_orphan_branch
;
43 enum branch_track track
;
44 struct diff_options diff_options
;
47 static int post_checkout_hook(struct commit
*old
, struct commit
*new,
50 return run_hook(NULL
, "post-checkout",
51 sha1_to_hex(old
? old
->object
.sha1
: null_sha1
),
52 sha1_to_hex(new ? new->object
.sha1
: null_sha1
),
53 changed
? "1" : "0", NULL
);
54 /* "new" can be NULL when checking out from the index before
59 static int update_some(const unsigned char *sha1
, const char *base
, int baselen
,
60 const char *pathname
, unsigned mode
, int stage
, void *context
)
63 struct cache_entry
*ce
;
66 return READ_TREE_RECURSIVE
;
68 len
= baselen
+ strlen(pathname
);
69 ce
= xcalloc(1, cache_entry_size(len
));
70 hashcpy(ce
->sha1
, sha1
);
71 memcpy(ce
->name
, base
, baselen
);
72 memcpy(ce
->name
+ baselen
, pathname
, len
- baselen
);
73 ce
->ce_flags
= create_ce_flags(len
, 0);
74 ce
->ce_mode
= create_ce_mode(mode
);
75 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
79 static int read_tree_some(struct tree
*tree
, const char **pathspec
)
81 read_tree_recursive(tree
, "", 0, 0, pathspec
, update_some
, NULL
);
83 /* update the index with the given tree's info
84 * for all args, expanding wildcards, and exit
85 * with any non-zero return code.
90 static int skip_same_name(struct cache_entry
*ce
, int pos
)
92 while (++pos
< active_nr
&&
93 !strcmp(active_cache
[pos
]->name
, ce
->name
))
98 static int check_stage(int stage
, struct cache_entry
*ce
, int pos
)
100 while (pos
< active_nr
&&
101 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
102 if (ce_stage(active_cache
[pos
]) == stage
)
106 return error("path '%s' does not have %s version",
108 (stage
== 2) ? "our" : "their");
111 static int check_all_stages(struct cache_entry
*ce
, int pos
)
113 if (ce_stage(ce
) != 1 ||
114 active_nr
<= pos
+ 2 ||
115 strcmp(active_cache
[pos
+1]->name
, ce
->name
) ||
116 ce_stage(active_cache
[pos
+1]) != 2 ||
117 strcmp(active_cache
[pos
+2]->name
, ce
->name
) ||
118 ce_stage(active_cache
[pos
+2]) != 3)
119 return error("path '%s' does not have all three versions",
124 static int checkout_stage(int stage
, struct cache_entry
*ce
, int pos
,
125 struct checkout
*state
)
127 while (pos
< active_nr
&&
128 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
129 if (ce_stage(active_cache
[pos
]) == stage
)
130 return checkout_entry(active_cache
[pos
], state
, NULL
);
133 return error("path '%s' does not have %s version",
135 (stage
== 2) ? "our" : "their");
138 static int checkout_merged(int pos
, struct checkout
*state
)
140 struct cache_entry
*ce
= active_cache
[pos
];
141 const char *path
= ce
->name
;
142 mmfile_t ancestor
, ours
, theirs
;
144 unsigned char sha1
[20];
145 mmbuffer_t result_buf
;
147 if (ce_stage(ce
) != 1 ||
148 active_nr
<= pos
+ 2 ||
149 strcmp(active_cache
[pos
+1]->name
, path
) ||
150 ce_stage(active_cache
[pos
+1]) != 2 ||
151 strcmp(active_cache
[pos
+2]->name
, path
) ||
152 ce_stage(active_cache
[pos
+2]) != 3)
153 return error("path '%s' does not have all 3 versions", path
);
155 read_mmblob(&ancestor
, active_cache
[pos
]->sha1
);
156 read_mmblob(&ours
, active_cache
[pos
+1]->sha1
);
157 read_mmblob(&theirs
, active_cache
[pos
+2]->sha1
);
160 * NEEDSWORK: re-create conflicts from merges with
161 * merge.renormalize set, too
163 status
= ll_merge(&result_buf
, path
, &ancestor
, "base",
164 &ours
, "ours", &theirs
, "theirs", NULL
);
168 if (status
< 0 || !result_buf
.ptr
) {
169 free(result_buf
.ptr
);
170 return error("path '%s': cannot merge", path
);
175 * There is absolutely no reason to write this as a blob object
176 * and create a phony cache entry just to leak. This hack is
177 * primarily to get to the write_entry() machinery that massages
178 * the contents to work-tree format and writes out which only
179 * allows it for a cache entry. The code in write_entry() needs
180 * to be refactored to allow us to feed a <buffer, size, mode>
181 * instead of a cache entry. Such a refactoring would help
182 * merge_recursive as well (it also writes the merge result to the
183 * object database even when it may contain conflicts).
185 if (write_sha1_file(result_buf
.ptr
, result_buf
.size
,
187 die("Unable to add merge result for '%s'", path
);
188 ce
= make_cache_entry(create_ce_mode(active_cache
[pos
+1]->ce_mode
),
192 die("make_cache_entry failed for path '%s'", path
);
193 status
= checkout_entry(ce
, state
, NULL
);
197 static int checkout_paths(struct tree
*source_tree
, const char **pathspec
,
198 struct checkout_opts
*opts
)
201 struct checkout state
;
202 static char *ps_matched
;
203 unsigned char rev
[20];
207 int stage
= opts
->writeout_stage
;
208 int merge
= opts
->merge
;
210 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
212 newfd
= hold_locked_index(lock_file
, 1);
213 if (read_cache_preload(pathspec
) < 0)
214 return error("corrupt index file");
217 read_tree_some(source_tree
, pathspec
);
219 for (pos
= 0; pathspec
[pos
]; pos
++)
221 ps_matched
= xcalloc(1, pos
);
223 for (pos
= 0; pos
< active_nr
; pos
++) {
224 struct cache_entry
*ce
= active_cache
[pos
];
225 match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, ps_matched
);
228 if (report_path_error(ps_matched
, pathspec
, 0))
231 /* "checkout -m path" to recreate conflicted state */
233 unmerge_cache(pathspec
);
235 /* Any unmerged paths? */
236 for (pos
= 0; pos
< active_nr
; pos
++) {
237 struct cache_entry
*ce
= active_cache
[pos
];
238 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
242 warning("path '%s' is unmerged", ce
->name
);
244 errs
|= check_stage(stage
, ce
, pos
);
245 } else if (opts
->merge
) {
246 errs
|= check_all_stages(ce
, pos
);
249 error("path '%s' is unmerged", ce
->name
);
251 pos
= skip_same_name(ce
, pos
) - 1;
257 /* Now we are committed to check them out */
258 memset(&state
, 0, sizeof(state
));
260 state
.refresh_cache
= 1;
261 for (pos
= 0; pos
< active_nr
; pos
++) {
262 struct cache_entry
*ce
= active_cache
[pos
];
263 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
265 errs
|= checkout_entry(ce
, &state
, NULL
);
269 errs
|= checkout_stage(stage
, ce
, pos
, &state
);
271 errs
|= checkout_merged(pos
, &state
);
272 pos
= skip_same_name(ce
, pos
) - 1;
276 if (write_cache(newfd
, active_cache
, active_nr
) ||
277 commit_locked_index(lock_file
))
278 die("unable to write new index file");
280 resolve_ref("HEAD", rev
, 0, &flag
);
281 head
= lookup_commit_reference_gently(rev
, 1);
283 errs
|= post_checkout_hook(head
, head
, 0);
287 static void show_local_changes(struct object
*head
, struct diff_options
*opts
)
290 /* I think we want full paths, even if we're in a subdirectory. */
291 init_revisions(&rev
, NULL
);
292 rev
.diffopt
.flags
= opts
->flags
;
293 rev
.diffopt
.output_format
|= DIFF_FORMAT_NAME_STATUS
;
294 if (diff_setup_done(&rev
.diffopt
) < 0)
295 die("diff_setup_done failed");
296 add_pending_object(&rev
, head
, NULL
);
297 run_diff_index(&rev
, 0);
300 static void describe_detached_head(char *msg
, struct commit
*commit
)
302 struct strbuf sb
= STRBUF_INIT
;
303 parse_commit(commit
);
304 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, &sb
);
305 fprintf(stderr
, "%s %s... %s\n", msg
,
306 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
310 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
312 struct unpack_trees_options opts
;
313 struct tree_desc tree_desc
;
315 memset(&opts
, 0, sizeof(opts
));
317 opts
.update
= worktree
;
318 opts
.skip_unmerged
= !worktree
;
321 opts
.fn
= oneway_merge
;
322 opts
.verbose_update
= !o
->quiet
;
323 opts
.src_index
= &the_index
;
324 opts
.dst_index
= &the_index
;
326 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
327 switch (unpack_trees(1, &tree_desc
, &opts
)) {
329 o
->writeout_error
= 1;
331 * We return 0 nevertheless, as the index is all right
332 * and more importantly we have made best efforts to
333 * update paths in the work tree, and we cannot revert
344 const char *name
; /* The short name used */
345 const char *path
; /* The full name of a real branch */
346 struct commit
*commit
; /* The named commit */
349 static void setup_branch_path(struct branch_info
*branch
)
351 struct strbuf buf
= STRBUF_INIT
;
353 strbuf_branchname(&buf
, branch
->name
);
354 if (strcmp(buf
.buf
, branch
->name
))
355 branch
->name
= xstrdup(buf
.buf
);
356 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
357 branch
->path
= strbuf_detach(&buf
, NULL
);
360 static int merge_working_tree(struct checkout_opts
*opts
,
361 struct branch_info
*old
, struct branch_info
*new)
364 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
365 int newfd
= hold_locked_index(lock_file
, 1);
367 if (read_cache_preload(NULL
) < 0)
368 return error("corrupt index file");
370 resolve_undo_clear();
372 ret
= reset_tree(new->commit
->tree
, opts
, 1);
376 struct tree_desc trees
[2];
378 struct unpack_trees_options topts
;
380 memset(&topts
, 0, sizeof(topts
));
382 topts
.src_index
= &the_index
;
383 topts
.dst_index
= &the_index
;
385 setup_unpack_trees_porcelain(&topts
, "checkout");
387 refresh_cache(REFRESH_QUIET
);
389 if (unmerged_cache()) {
390 error("you need to resolve your current index first");
394 /* 2-way merge to the new branch */
395 topts
.initial_checkout
= is_cache_unborn();
398 topts
.gently
= opts
->merge
&& old
->commit
;
399 topts
.verbose_update
= !opts
->quiet
;
400 topts
.fn
= twoway_merge
;
401 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
402 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
403 topts
.dir
->exclude_per_dir
= ".gitignore";
404 tree
= parse_tree_indirect(old
->commit
?
405 old
->commit
->object
.sha1
:
406 (unsigned char *)EMPTY_TREE_SHA1_BIN
);
407 init_tree_desc(&trees
[0], tree
->buffer
, tree
->size
);
408 tree
= parse_tree_indirect(new->commit
->object
.sha1
);
409 init_tree_desc(&trees
[1], tree
->buffer
, tree
->size
);
411 ret
= unpack_trees(2, trees
, &topts
);
414 * Unpack couldn't do a trivial merge; either
415 * give up or do a real merge, depending on
416 * whether the merge flag was used.
420 struct merge_options o
;
425 * Without old->commit, the below is the same as
426 * the two-tree unpack we already tried and failed.
431 /* Do more real merge */
434 * We update the index fully, then write the
435 * tree from the index, then merge the new
436 * branch with the current tree, with the old
437 * branch as the base. Then we reset the index
438 * (but not the working tree) to the new
439 * branch, leaving the working tree as the
440 * merged version, but skipping unmerged
441 * entries in the index.
444 add_files_to_cache(NULL
, NULL
, 0);
446 * NEEDSWORK: carrying over local changes
447 * when branches have different end-of-line
448 * normalization (or clean+smudge rules) is
449 * a pain; plumb in an option to set
452 init_merge_options(&o
);
454 work
= write_tree_from_memory(&o
);
456 ret
= reset_tree(new->commit
->tree
, opts
, 1);
459 o
.ancestor
= old
->name
;
460 o
.branch1
= new->name
;
462 merge_trees(&o
, new->commit
->tree
, work
,
463 old
->commit
->tree
, &result
);
464 ret
= reset_tree(new->commit
->tree
, opts
, 0);
470 if (write_cache(newfd
, active_cache
, active_nr
) ||
471 commit_locked_index(lock_file
))
472 die("unable to write new index file");
474 if (!opts
->force
&& !opts
->quiet
)
475 show_local_changes(&new->commit
->object
, &opts
->diff_options
);
480 static void report_tracking(struct branch_info
*new)
482 struct strbuf sb
= STRBUF_INIT
;
483 struct branch
*branch
= branch_get(new->name
);
485 if (!format_tracking_info(branch
, &sb
))
487 fputs(sb
.buf
, stdout
);
491 static void detach_advice(const char *old_path
, const char *new_name
)
494 "Note: checking out '%s'.\n\n"
495 "You are in 'detached HEAD' state. You can look around, make experimental\n"
496 "changes and commit them, and you can discard any commits you make in this\n"
497 "state without impacting any branches by performing another checkout.\n\n"
498 "If you want to create a new branch to retain commits you create, you may\n"
499 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
500 " git checkout -b new_branch_name\n\n";
502 fprintf(stderr
, fmt
, new_name
);
505 static void update_refs_for_switch(struct checkout_opts
*opts
,
506 struct branch_info
*old
,
507 struct branch_info
*new)
509 struct strbuf msg
= STRBUF_INIT
;
510 const char *old_desc
;
511 if (opts
->new_branch
) {
512 if (opts
->new_orphan_branch
) {
513 if (opts
->new_branch_log
&& !log_all_ref_updates
) {
515 char log_file
[PATH_MAX
];
516 char *ref_name
= mkpath("refs/heads/%s", opts
->new_orphan_branch
);
518 temp
= log_all_ref_updates
;
519 log_all_ref_updates
= 1;
520 if (log_ref_setup(ref_name
, log_file
, sizeof(log_file
))) {
521 fprintf(stderr
, "Can not do reflog for '%s'\n",
522 opts
->new_orphan_branch
);
523 log_all_ref_updates
= temp
;
526 log_all_ref_updates
= temp
;
530 create_branch(old
->name
, opts
->new_branch
, new->name
,
531 opts
->new_branch_force
? 1 : 0,
532 opts
->new_branch_log
, opts
->track
);
533 new->name
= opts
->new_branch
;
534 setup_branch_path(new);
537 old_desc
= old
->name
;
538 if (!old_desc
&& old
->commit
)
539 old_desc
= sha1_to_hex(old
->commit
->object
.sha1
);
540 strbuf_addf(&msg
, "checkout: moving from %s to %s",
541 old_desc
? old_desc
: "(invalid)", new->name
);
544 create_symref("HEAD", new->path
, msg
.buf
);
546 if (old
->path
&& !strcmp(new->path
, old
->path
))
547 fprintf(stderr
, "Already on '%s'\n",
549 else if (opts
->new_branch
)
550 fprintf(stderr
, "Switched to%s branch '%s'\n",
551 opts
->branch_exists
? " and reset" : " a new",
554 fprintf(stderr
, "Switched to branch '%s'\n",
557 if (old
->path
&& old
->name
) {
558 char log_file
[PATH_MAX
], ref_file
[PATH_MAX
];
560 git_snpath(log_file
, sizeof(log_file
), "logs/%s", old
->path
);
561 git_snpath(ref_file
, sizeof(ref_file
), "%s", old
->path
);
562 if (!file_exists(ref_file
) && file_exists(log_file
))
563 remove_path(log_file
);
565 } else if (strcmp(new->name
, "HEAD")) {
566 update_ref(msg
.buf
, "HEAD", new->commit
->object
.sha1
, NULL
,
567 REF_NODEREF
, DIE_ON_ERR
);
569 if (old
->path
&& advice_detached_head
)
570 detach_advice(old
->path
, new->name
);
571 describe_detached_head("HEAD is now at", new->commit
);
574 remove_branch_state();
575 strbuf_release(&msg
);
576 if (!opts
->quiet
&& (new->path
|| !strcmp(new->name
, "HEAD")))
577 report_tracking(new);
580 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
583 struct branch_info old
;
584 unsigned char rev
[20];
586 memset(&old
, 0, sizeof(old
));
587 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
588 old
.commit
= lookup_commit_reference_gently(rev
, 1);
589 if (!(flag
& REF_ISSYMREF
))
592 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
593 old
.name
= old
.path
+ strlen("refs/heads/");
597 new->commit
= old
.commit
;
599 die("You are on a branch yet to be born");
600 parse_commit(new->commit
);
603 ret
= merge_working_tree(opts
, &old
, new);
608 * If we were on a detached HEAD, but have now moved to
609 * a new commit, we want to mention the old commit once more
610 * to remind the user that it might be lost.
612 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
613 describe_detached_head("Previous HEAD position was", old
.commit
);
615 update_refs_for_switch(opts
, &old
, new);
617 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
618 return ret
|| opts
->writeout_error
;
621 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
623 if (!strcmp(var
, "diff.ignoresubmodules")) {
624 struct checkout_opts
*opts
= cb
;
625 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
629 if (!prefixcmp(var
, "submodule."))
630 return parse_submodule_config_option(var
, value
);
632 return git_xmerge_config(var
, value
, NULL
);
635 static int interactive_checkout(const char *revision
, const char **pathspec
,
636 struct checkout_opts
*opts
)
638 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
641 struct tracking_name_data
{
647 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
648 int flags
, void *cb_data
)
650 struct tracking_name_data
*cb
= cb_data
;
653 if (prefixcmp(refname
, "refs/remotes/"))
655 slash
= strchr(refname
+ 13, '/');
656 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
662 cb
->remote
= xstrdup(refname
);
666 static const char *unique_tracking_name(const char *name
)
668 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
670 for_each_ref(check_tracking_name
, &cb_data
);
672 return cb_data
.remote
;
673 free(cb_data
.remote
);
677 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
679 struct checkout_opts opts
;
680 unsigned char rev
[20];
682 struct branch_info
new;
683 struct tree
*source_tree
= NULL
;
684 char *conflict_style
= NULL
;
686 int dwim_new_local_branch
= 1;
687 struct option options
[] = {
688 OPT__QUIET(&opts
.quiet
, "suppress progress reporting"),
689 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
690 "create and checkout a new branch"),
691 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
692 "create/reset and checkout a branch"),
693 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "create reflog for new branch"),
694 OPT_SET_INT('t', "track", &opts
.track
, "set upstream info for new branch",
695 BRANCH_TRACK_EXPLICIT
),
696 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
697 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "checkout our version for unmerged files",
699 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "checkout their version for unmerged files",
701 OPT__FORCE(&opts
.force
, "force checkout (throw away local modifications)"),
702 OPT_BOOLEAN('m', "merge", &opts
.merge
, "perform a 3-way merge with the new branch"),
703 OPT_STRING(0, "conflict", &conflict_style
, "style",
704 "conflict style (merge or diff3)"),
705 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
706 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
707 "second guess 'git checkout no-such-branch'",
708 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
713 memset(&opts
, 0, sizeof(opts
));
714 memset(&new, 0, sizeof(new));
717 git_config(git_checkout_config
, &opts
);
719 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
721 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
722 PARSE_OPT_KEEP_DASHDASH
);
724 /* we can assume from now on new_branch = !new_branch_force */
725 if (opts
.new_branch
&& opts
.new_branch_force
)
726 die("-B cannot be used with -b");
728 /* copy -B over to -b, so that we can just check the latter */
729 if (opts
.new_branch_force
)
730 opts
.new_branch
= opts
.new_branch_force
;
732 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
733 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
))
734 die ("--patch is incompatible with all other options");
736 /* --track without -b should DWIM */
737 if (0 < opts
.track
&& !opts
.new_branch
) {
738 const char *argv0
= argv
[0];
739 if (!argc
|| !strcmp(argv0
, "--"))
740 die ("--track needs a branch name");
741 if (!prefixcmp(argv0
, "refs/"))
743 if (!prefixcmp(argv0
, "remotes/"))
745 argv0
= strchr(argv0
, '/');
746 if (!argv0
|| !argv0
[1])
747 die ("Missing branch name; try -b");
748 opts
.new_branch
= argv0
+ 1;
751 if (opts
.new_orphan_branch
) {
753 die("--orphan and -b|-B are mutually exclusive");
755 die("--orphan cannot be used with -t");
756 opts
.new_branch
= opts
.new_orphan_branch
;
759 if (conflict_style
) {
760 opts
.merge
= 1; /* implied */
761 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
764 if (opts
.force
&& opts
.merge
)
765 die("git checkout: -f and -m are incompatible");
768 * case 1: git checkout <ref> -- [<paths>]
770 * <ref> must be a valid tree, everything after the '--' must be
773 * case 2: git checkout -- [<paths>]
775 * everything after the '--' must be paths.
777 * case 3: git checkout <something> [<paths>]
779 * With no paths, if <something> is a commit, that is to
780 * switch to the branch or detach HEAD at it. As a special case,
781 * if <something> is A...B (missing A or B means HEAD but you can
782 * omit at most one side), and if there is a unique merge base
783 * between A and B, A...B names that merge base.
785 * With no paths, if <something> is _not_ a commit, no -t nor -b
786 * was given, and there is a remote-tracking branch whose name is
787 * <something> in one and only one remote, then this is a short-hand
788 * to fork local <something> from that remote-tracking branch.
790 * Otherwise <something> shall not be ambiguous.
791 * - If it's *only* a reference, treat it like case (1).
792 * - If it's only a path, treat it like case (2).
797 if (!strcmp(argv
[0], "--")) { /* case (2) */
804 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
806 if (!strcmp(arg
, "-"))
809 if (get_sha1_mb(arg
, rev
)) {
810 if (has_dash_dash
) /* case (1) */
811 die("invalid reference: %s", arg
);
813 dwim_new_local_branch
&&
814 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
816 !check_filename(NULL
, arg
) &&
818 const char *remote
= unique_tracking_name(arg
);
819 if (!remote
|| get_sha1(remote
, rev
))
821 opts
.new_branch
= arg
;
823 /* DWIMmed to create local branch */
829 /* we can't end up being in (2) anymore, eat the argument */
834 if ((new.commit
= lookup_commit_reference_gently(rev
, 1))) {
835 setup_branch_path(&new);
837 if ((check_ref_format(new.path
) == CHECK_REF_FORMAT_OK
) &&
838 resolve_ref(new.path
, rev
, 1, NULL
))
842 parse_commit(new.commit
);
843 source_tree
= new.commit
->tree
;
845 source_tree
= parse_tree_indirect(rev
);
847 if (!source_tree
) /* case (1): want a tree */
848 die("reference is not a tree: %s", arg
);
849 if (!has_dash_dash
) {/* case (3 -> 1) */
851 * Do not complain the most common case
852 * git checkout branch
853 * even if there happen to be a file called 'branch';
854 * it would be extremely annoying.
857 verify_non_filename(NULL
, arg
);
867 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
868 opts
.track
= git_branch_track
;
871 const char **pathspec
= get_pathspec(prefix
, argv
);
874 die("invalid path specification");
877 return interactive_checkout(new.name
, pathspec
, &opts
);
880 if (opts
.new_branch
) {
882 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]);
884 die("git checkout: updating paths is incompatible with switching branches.");
888 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
889 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
891 return checkout_paths(source_tree
, pathspec
, &opts
);
895 return interactive_checkout(new.name
, NULL
, &opts
);
897 if (opts
.new_branch
) {
898 struct strbuf buf
= STRBUF_INIT
;
899 if (strbuf_check_branch_ref(&buf
, opts
.new_branch
))
900 die("git checkout: we do not like '%s' as a branch name.",
902 if (!get_sha1(buf
.buf
, rev
)) {
903 opts
.branch_exists
= 1;
904 if (!opts
.new_branch_force
)
905 die("git checkout: branch %s already exists",
908 strbuf_release(&buf
);
911 if (new.name
&& !new.commit
) {
912 die("Cannot switch branch to a non-commit.");
914 if (opts
.writeout_stage
)
915 die("--ours/--theirs is incompatible with switching branches.");
917 return switch_branches(&opts
, &new);