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", 0);
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 struct pretty_print_context ctx
= {0};
304 parse_commit(commit
);
305 pretty_print_commit(CMIT_FMT_ONELINE
, commit
, &sb
, &ctx
);
306 fprintf(stderr
, "%s %s... %s\n", msg
,
307 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
311 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
313 struct unpack_trees_options opts
;
314 struct tree_desc tree_desc
;
316 memset(&opts
, 0, sizeof(opts
));
318 opts
.update
= worktree
;
319 opts
.skip_unmerged
= !worktree
;
322 opts
.fn
= oneway_merge
;
323 opts
.verbose_update
= !o
->quiet
;
324 opts
.src_index
= &the_index
;
325 opts
.dst_index
= &the_index
;
327 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
328 switch (unpack_trees(1, &tree_desc
, &opts
)) {
330 o
->writeout_error
= 1;
332 * We return 0 nevertheless, as the index is all right
333 * and more importantly we have made best efforts to
334 * update paths in the work tree, and we cannot revert
345 const char *name
; /* The short name used */
346 const char *path
; /* The full name of a real branch */
347 struct commit
*commit
; /* The named commit */
350 static void setup_branch_path(struct branch_info
*branch
)
352 struct strbuf buf
= STRBUF_INIT
;
354 strbuf_branchname(&buf
, branch
->name
);
355 if (strcmp(buf
.buf
, branch
->name
))
356 branch
->name
= xstrdup(buf
.buf
);
357 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
358 branch
->path
= strbuf_detach(&buf
, NULL
);
361 static int merge_working_tree(struct checkout_opts
*opts
,
362 struct branch_info
*old
, struct branch_info
*new)
365 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
366 int newfd
= hold_locked_index(lock_file
, 1);
368 if (read_cache_preload(NULL
) < 0)
369 return error("corrupt index file");
371 resolve_undo_clear();
373 ret
= reset_tree(new->commit
->tree
, opts
, 1);
377 struct tree_desc trees
[2];
379 struct unpack_trees_options topts
;
381 memset(&topts
, 0, sizeof(topts
));
383 topts
.src_index
= &the_index
;
384 topts
.dst_index
= &the_index
;
386 set_porcelain_error_msgs(topts
.msgs
, "checkout");
388 refresh_cache(REFRESH_QUIET
);
390 if (unmerged_cache()) {
391 error("you need to resolve your current index first");
395 /* 2-way merge to the new branch */
396 topts
.initial_checkout
= is_cache_unborn();
399 topts
.gently
= opts
->merge
&& old
->commit
;
400 topts
.verbose_update
= !opts
->quiet
;
401 topts
.fn
= twoway_merge
;
402 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
403 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
404 topts
.dir
->exclude_per_dir
= ".gitignore";
405 topts
.show_all_errors
= 1;
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 (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
);
578 if (!opts
->quiet
&& (new->path
|| !strcmp(new->name
, "HEAD")))
579 report_tracking(new);
582 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
585 struct branch_info old
;
586 unsigned char rev
[20];
588 memset(&old
, 0, sizeof(old
));
589 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
590 old
.commit
= lookup_commit_reference_gently(rev
, 1);
591 if (!(flag
& REF_ISSYMREF
))
594 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
595 old
.name
= old
.path
+ strlen("refs/heads/");
599 new->commit
= old
.commit
;
601 die("You are on a branch yet to be born");
602 parse_commit(new->commit
);
605 ret
= merge_working_tree(opts
, &old
, new);
610 * If we were on a detached HEAD, but have now moved to
611 * a new commit, we want to mention the old commit once more
612 * to remind the user that it might be lost.
614 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
615 describe_detached_head("Previous HEAD position was", old
.commit
);
617 update_refs_for_switch(opts
, &old
, new);
619 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
620 return ret
|| opts
->writeout_error
;
623 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
625 if (!strcmp(var
, "diff.ignoresubmodules")) {
626 struct checkout_opts
*opts
= cb
;
627 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
631 if (!prefixcmp(var
, "submodule."))
632 return parse_submodule_config_option(var
, value
);
634 return git_xmerge_config(var
, value
, NULL
);
637 static int interactive_checkout(const char *revision
, const char **pathspec
,
638 struct checkout_opts
*opts
)
640 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
643 struct tracking_name_data
{
649 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
650 int flags
, void *cb_data
)
652 struct tracking_name_data
*cb
= cb_data
;
655 if (prefixcmp(refname
, "refs/remotes/"))
657 slash
= strchr(refname
+ 13, '/');
658 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
664 cb
->remote
= xstrdup(refname
);
668 static const char *unique_tracking_name(const char *name
)
670 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
672 for_each_ref(check_tracking_name
, &cb_data
);
674 return cb_data
.remote
;
675 free(cb_data
.remote
);
679 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
681 struct checkout_opts opts
;
682 unsigned char rev
[20];
684 struct branch_info
new;
685 struct tree
*source_tree
= NULL
;
686 char *conflict_style
= NULL
;
688 int dwim_new_local_branch
= 1;
689 struct option options
[] = {
690 OPT__QUIET(&opts
.quiet
),
691 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
692 "create and checkout a new branch"),
693 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
694 "create/reset and checkout a branch"),
695 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "log for new branch"),
696 OPT_SET_INT('t', "track", &opts
.track
, "track",
697 BRANCH_TRACK_EXPLICIT
),
698 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
699 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "stage",
701 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "stage",
703 OPT_BOOLEAN('f', "force", &opts
.force
, "force"),
704 OPT_BOOLEAN('m', "merge", &opts
.merge
, "merge"),
705 OPT_STRING(0, "conflict", &conflict_style
, "style",
706 "conflict style (merge or diff3)"),
707 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
708 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
709 "second guess 'git checkout no-such-branch'",
710 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
715 memset(&opts
, 0, sizeof(opts
));
716 memset(&new, 0, sizeof(new));
719 git_config(git_checkout_config
, &opts
);
721 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
723 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
724 PARSE_OPT_KEEP_DASHDASH
);
726 /* we can assume from now on new_branch = !new_branch_force */
727 if (opts
.new_branch
&& opts
.new_branch_force
)
728 die("-B cannot be used with -b");
730 /* copy -B over to -b, so that we can just check the latter */
731 if (opts
.new_branch_force
)
732 opts
.new_branch
= opts
.new_branch_force
;
734 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
735 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
))
736 die ("--patch is incompatible with all other options");
738 /* --track without -b should DWIM */
739 if (0 < opts
.track
&& !opts
.new_branch
) {
740 const char *argv0
= argv
[0];
741 if (!argc
|| !strcmp(argv0
, "--"))
742 die ("--track needs a branch name");
743 if (!prefixcmp(argv0
, "refs/"))
745 if (!prefixcmp(argv0
, "remotes/"))
747 argv0
= strchr(argv0
, '/');
748 if (!argv0
|| !argv0
[1])
749 die ("Missing branch name; try -b");
750 opts
.new_branch
= argv0
+ 1;
753 if (opts
.new_orphan_branch
) {
755 die("--orphan and -b|-B are mutually exclusive");
757 die("--orphan cannot be used with -t");
758 opts
.new_branch
= opts
.new_orphan_branch
;
761 if (conflict_style
) {
762 opts
.merge
= 1; /* implied */
763 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
766 if (opts
.force
&& opts
.merge
)
767 die("git checkout: -f and -m are incompatible");
770 * case 1: git checkout <ref> -- [<paths>]
772 * <ref> must be a valid tree, everything after the '--' must be
775 * case 2: git checkout -- [<paths>]
777 * everything after the '--' must be paths.
779 * case 3: git checkout <something> [<paths>]
781 * With no paths, if <something> is a commit, that is to
782 * switch to the branch or detach HEAD at it. As a special case,
783 * if <something> is A...B (missing A or B means HEAD but you can
784 * omit at most one side), and if there is a unique merge base
785 * between A and B, A...B names that merge base.
787 * With no paths, if <something> is _not_ a commit, no -t nor -b
788 * was given, and there is a tracking branch whose name is
789 * <something> in one and only one remote, then this is a short-hand
790 * to fork local <something> from that remote tracking branch.
792 * Otherwise <something> shall not be ambiguous.
793 * - If it's *only* a reference, treat it like case (1).
794 * - If it's only a path, treat it like case (2).
799 if (!strcmp(argv
[0], "--")) { /* case (2) */
806 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
808 if (!strcmp(arg
, "-"))
811 if (get_sha1_mb(arg
, rev
)) {
812 if (has_dash_dash
) /* case (1) */
813 die("invalid reference: %s", arg
);
815 dwim_new_local_branch
&&
816 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
818 !check_filename(NULL
, arg
) &&
820 const char *remote
= unique_tracking_name(arg
);
821 if (!remote
|| get_sha1(remote
, rev
))
823 opts
.new_branch
= arg
;
825 /* DWIMmed to create local branch */
831 /* we can't end up being in (2) anymore, eat the argument */
836 if ((new.commit
= lookup_commit_reference_gently(rev
, 1))) {
837 setup_branch_path(&new);
839 if ((check_ref_format(new.path
) == CHECK_REF_FORMAT_OK
) &&
840 resolve_ref(new.path
, rev
, 1, NULL
))
844 parse_commit(new.commit
);
845 source_tree
= new.commit
->tree
;
847 source_tree
= parse_tree_indirect(rev
);
849 if (!source_tree
) /* case (1): want a tree */
850 die("reference is not a tree: %s", arg
);
851 if (!has_dash_dash
) {/* case (3 -> 1) */
853 * Do not complain the most common case
854 * git checkout branch
855 * even if there happen to be a file called 'branch';
856 * it would be extremely annoying.
859 verify_non_filename(NULL
, arg
);
869 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
870 opts
.track
= git_branch_track
;
873 const char **pathspec
= get_pathspec(prefix
, argv
);
876 die("invalid path specification");
879 return interactive_checkout(new.name
, pathspec
, &opts
);
882 if (opts
.new_branch
) {
884 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]);
886 die("git checkout: updating paths is incompatible with switching branches.");
890 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
891 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
893 return checkout_paths(source_tree
, pathspec
, &opts
);
897 return interactive_checkout(new.name
, NULL
, &opts
);
899 if (opts
.new_branch
) {
900 struct strbuf buf
= STRBUF_INIT
;
901 if (strbuf_check_branch_ref(&buf
, opts
.new_branch
))
902 die("git checkout: we do not like '%s' as a branch name.",
904 if (!get_sha1(buf
.buf
, rev
)) {
905 opts
.branch_exists
= 1;
906 if (!opts
.new_branch_force
)
907 die("git checkout: branch %s already exists",
910 strbuf_release(&buf
);
913 if (new.name
&& !new.commit
) {
914 die("Cannot switch branch to a non-commit.");
916 if (opts
.writeout_stage
)
917 die("--ours/--theirs is incompatible with switching branches.");
919 return switch_branches(&opts
, &new);