3 #include "parse-options.h"
8 #include "cache-tree.h"
9 #include "unpack-trees.h"
11 #include "run-command.h"
12 #include "merge-recursive.h"
18 #include "xdiff-interface.h"
20 #include "resolve-undo.h"
21 #include "submodule.h"
23 static const char * const checkout_usage
[] = {
24 "git checkout [options] <branch>",
25 "git checkout [options] [<branch>] -- <file>...",
29 struct checkout_opts
{
37 /* not set by parse_options */
40 const char *new_branch
;
41 const char *new_branch_force
;
42 const char *new_orphan_branch
;
44 enum branch_track track
;
45 struct diff_options diff_options
;
48 static int post_checkout_hook(struct commit
*old
, struct commit
*new,
51 return run_hook(NULL
, "post-checkout",
52 sha1_to_hex(old
? old
->object
.sha1
: null_sha1
),
53 sha1_to_hex(new ? new->object
.sha1
: null_sha1
),
54 changed
? "1" : "0", NULL
);
55 /* "new" can be NULL when checking out from the index before
60 static int update_some(const unsigned char *sha1
, const char *base
, int baselen
,
61 const char *pathname
, unsigned mode
, int stage
, void *context
)
64 struct cache_entry
*ce
;
67 return READ_TREE_RECURSIVE
;
69 len
= baselen
+ strlen(pathname
);
70 ce
= xcalloc(1, cache_entry_size(len
));
71 hashcpy(ce
->sha1
, sha1
);
72 memcpy(ce
->name
, base
, baselen
);
73 memcpy(ce
->name
+ baselen
, pathname
, len
- baselen
);
74 ce
->ce_flags
= create_ce_flags(len
, 0);
75 ce
->ce_mode
= create_ce_mode(mode
);
76 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
80 static int read_tree_some(struct tree
*tree
, const char **pathspec
)
83 init_pathspec(&ps
, pathspec
);
84 read_tree_recursive(tree
, "", 0, 0, &ps
, update_some
, NULL
);
87 /* update the index with the given tree's info
88 * for all args, expanding wildcards, and exit
89 * with any non-zero return code.
94 static int skip_same_name(struct cache_entry
*ce
, int pos
)
96 while (++pos
< active_nr
&&
97 !strcmp(active_cache
[pos
]->name
, ce
->name
))
102 static int check_stage(int stage
, struct cache_entry
*ce
, int pos
)
104 while (pos
< active_nr
&&
105 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
106 if (ce_stage(active_cache
[pos
]) == stage
)
111 return error(_("path '%s' does not have our version"), ce
->name
);
113 return error(_("path '%s' does not have their version"), ce
->name
);
116 static int check_all_stages(struct cache_entry
*ce
, int pos
)
118 if (ce_stage(ce
) != 1 ||
119 active_nr
<= pos
+ 2 ||
120 strcmp(active_cache
[pos
+1]->name
, ce
->name
) ||
121 ce_stage(active_cache
[pos
+1]) != 2 ||
122 strcmp(active_cache
[pos
+2]->name
, ce
->name
) ||
123 ce_stage(active_cache
[pos
+2]) != 3)
124 return error(_("path '%s' does not have all three versions"),
129 static int checkout_stage(int stage
, struct cache_entry
*ce
, int pos
,
130 struct checkout
*state
)
132 while (pos
< active_nr
&&
133 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
134 if (ce_stage(active_cache
[pos
]) == stage
)
135 return checkout_entry(active_cache
[pos
], state
, NULL
);
139 return error(_("path '%s' does not have our version"), ce
->name
);
141 return error(_("path '%s' does not have their version"), ce
->name
);
144 static int checkout_merged(int pos
, struct checkout
*state
)
146 struct cache_entry
*ce
= active_cache
[pos
];
147 const char *path
= ce
->name
;
148 mmfile_t ancestor
, ours
, theirs
;
150 unsigned char sha1
[20];
151 mmbuffer_t result_buf
;
153 if (ce_stage(ce
) != 1 ||
154 active_nr
<= pos
+ 2 ||
155 strcmp(active_cache
[pos
+1]->name
, path
) ||
156 ce_stage(active_cache
[pos
+1]) != 2 ||
157 strcmp(active_cache
[pos
+2]->name
, path
) ||
158 ce_stage(active_cache
[pos
+2]) != 3)
159 return error(_("path '%s' does not have all 3 versions"), path
);
161 read_mmblob(&ancestor
, active_cache
[pos
]->sha1
);
162 read_mmblob(&ours
, active_cache
[pos
+1]->sha1
);
163 read_mmblob(&theirs
, active_cache
[pos
+2]->sha1
);
166 * NEEDSWORK: re-create conflicts from merges with
167 * merge.renormalize set, too
169 status
= ll_merge(&result_buf
, path
, &ancestor
, "base",
170 &ours
, "ours", &theirs
, "theirs", NULL
);
174 if (status
< 0 || !result_buf
.ptr
) {
175 free(result_buf
.ptr
);
176 return error(_("path '%s': cannot merge"), path
);
181 * There is absolutely no reason to write this as a blob object
182 * and create a phony cache entry just to leak. This hack is
183 * primarily to get to the write_entry() machinery that massages
184 * the contents to work-tree format and writes out which only
185 * allows it for a cache entry. The code in write_entry() needs
186 * to be refactored to allow us to feed a <buffer, size, mode>
187 * instead of a cache entry. Such a refactoring would help
188 * merge_recursive as well (it also writes the merge result to the
189 * object database even when it may contain conflicts).
191 if (write_sha1_file(result_buf
.ptr
, result_buf
.size
,
193 die(_("Unable to add merge result for '%s'"), path
);
194 ce
= make_cache_entry(create_ce_mode(active_cache
[pos
+1]->ce_mode
),
198 die(_("make_cache_entry failed for path '%s'"), path
);
199 status
= checkout_entry(ce
, state
, NULL
);
203 static int checkout_paths(struct tree
*source_tree
, const char **pathspec
,
204 struct checkout_opts
*opts
)
207 struct checkout state
;
208 static char *ps_matched
;
209 unsigned char rev
[20];
213 int stage
= opts
->writeout_stage
;
214 int merge
= opts
->merge
;
216 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
218 newfd
= hold_locked_index(lock_file
, 1);
219 if (read_cache_preload(pathspec
) < 0)
220 return error(_("corrupt index file"));
223 read_tree_some(source_tree
, pathspec
);
225 for (pos
= 0; pathspec
[pos
]; pos
++)
227 ps_matched
= xcalloc(1, pos
);
229 for (pos
= 0; pos
< active_nr
; pos
++) {
230 struct cache_entry
*ce
= active_cache
[pos
];
231 match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, ps_matched
);
234 if (report_path_error(ps_matched
, pathspec
, 0))
237 /* "checkout -m path" to recreate conflicted state */
239 unmerge_cache(pathspec
);
241 /* Any unmerged paths? */
242 for (pos
= 0; pos
< active_nr
; pos
++) {
243 struct cache_entry
*ce
= active_cache
[pos
];
244 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
248 warning(_("path '%s' is unmerged"), ce
->name
);
250 errs
|= check_stage(stage
, ce
, pos
);
251 } else if (opts
->merge
) {
252 errs
|= check_all_stages(ce
, pos
);
255 error(_("path '%s' is unmerged"), ce
->name
);
257 pos
= skip_same_name(ce
, pos
) - 1;
263 /* Now we are committed to check them out */
264 memset(&state
, 0, sizeof(state
));
266 state
.refresh_cache
= 1;
267 for (pos
= 0; pos
< active_nr
; pos
++) {
268 struct cache_entry
*ce
= active_cache
[pos
];
269 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
271 errs
|= checkout_entry(ce
, &state
, NULL
);
275 errs
|= checkout_stage(stage
, ce
, pos
, &state
);
277 errs
|= checkout_merged(pos
, &state
);
278 pos
= skip_same_name(ce
, pos
) - 1;
282 if (write_cache(newfd
, active_cache
, active_nr
) ||
283 commit_locked_index(lock_file
))
284 die(_("unable to write new index file"));
286 resolve_ref("HEAD", rev
, 0, &flag
);
287 head
= lookup_commit_reference_gently(rev
, 1);
289 errs
|= post_checkout_hook(head
, head
, 0);
293 static void show_local_changes(struct object
*head
, struct diff_options
*opts
)
296 /* I think we want full paths, even if we're in a subdirectory. */
297 init_revisions(&rev
, NULL
);
298 rev
.diffopt
.flags
= opts
->flags
;
299 rev
.diffopt
.output_format
|= DIFF_FORMAT_NAME_STATUS
;
300 if (diff_setup_done(&rev
.diffopt
) < 0)
301 die(_("diff_setup_done failed"));
302 add_pending_object(&rev
, head
, NULL
);
303 run_diff_index(&rev
, 0);
306 static void describe_detached_head(const char *msg
, struct commit
*commit
)
308 struct strbuf sb
= STRBUF_INIT
;
309 parse_commit(commit
);
310 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, &sb
);
311 fprintf(stderr
, "%s %s... %s\n", msg
,
312 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
316 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
318 struct unpack_trees_options opts
;
319 struct tree_desc tree_desc
;
321 memset(&opts
, 0, sizeof(opts
));
323 opts
.update
= worktree
;
324 opts
.skip_unmerged
= !worktree
;
327 opts
.fn
= oneway_merge
;
328 opts
.verbose_update
= !o
->quiet
;
329 opts
.src_index
= &the_index
;
330 opts
.dst_index
= &the_index
;
332 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
333 switch (unpack_trees(1, &tree_desc
, &opts
)) {
335 o
->writeout_error
= 1;
337 * We return 0 nevertheless, as the index is all right
338 * and more importantly we have made best efforts to
339 * update paths in the work tree, and we cannot revert
350 const char *name
; /* The short name used */
351 const char *path
; /* The full name of a real branch */
352 struct commit
*commit
; /* The named commit */
355 static void setup_branch_path(struct branch_info
*branch
)
357 struct strbuf buf
= STRBUF_INIT
;
359 strbuf_branchname(&buf
, branch
->name
);
360 if (strcmp(buf
.buf
, branch
->name
))
361 branch
->name
= xstrdup(buf
.buf
);
362 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
363 branch
->path
= strbuf_detach(&buf
, NULL
);
366 static int merge_working_tree(struct checkout_opts
*opts
,
367 struct branch_info
*old
, struct branch_info
*new)
370 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
371 int newfd
= hold_locked_index(lock_file
, 1);
373 if (read_cache_preload(NULL
) < 0)
374 return error(_("corrupt index file"));
376 resolve_undo_clear();
378 ret
= reset_tree(new->commit
->tree
, opts
, 1);
382 struct tree_desc trees
[2];
384 struct unpack_trees_options topts
;
386 memset(&topts
, 0, sizeof(topts
));
388 topts
.src_index
= &the_index
;
389 topts
.dst_index
= &the_index
;
391 setup_unpack_trees_porcelain(&topts
, "checkout");
393 refresh_cache(REFRESH_QUIET
);
395 if (unmerged_cache()) {
396 error(_("you need to resolve your current index first"));
400 /* 2-way merge to the new branch */
401 topts
.initial_checkout
= is_cache_unborn();
404 topts
.gently
= opts
->merge
&& old
->commit
;
405 topts
.verbose_update
= !opts
->quiet
;
406 topts
.fn
= twoway_merge
;
407 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
408 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
409 topts
.dir
->exclude_per_dir
= ".gitignore";
410 tree
= parse_tree_indirect(old
->commit
?
411 old
->commit
->object
.sha1
:
412 EMPTY_TREE_SHA1_BIN
);
413 init_tree_desc(&trees
[0], tree
->buffer
, tree
->size
);
414 tree
= parse_tree_indirect(new->commit
->object
.sha1
);
415 init_tree_desc(&trees
[1], tree
->buffer
, tree
->size
);
417 ret
= unpack_trees(2, trees
, &topts
);
420 * Unpack couldn't do a trivial merge; either
421 * give up or do a real merge, depending on
422 * whether the merge flag was used.
426 struct merge_options o
;
431 * Without old->commit, the below is the same as
432 * the two-tree unpack we already tried and failed.
437 /* Do more real merge */
440 * We update the index fully, then write the
441 * tree from the index, then merge the new
442 * branch with the current tree, with the old
443 * branch as the base. Then we reset the index
444 * (but not the working tree) to the new
445 * branch, leaving the working tree as the
446 * merged version, but skipping unmerged
447 * entries in the index.
450 add_files_to_cache(NULL
, NULL
, 0);
452 * NEEDSWORK: carrying over local changes
453 * when branches have different end-of-line
454 * normalization (or clean+smudge rules) is
455 * a pain; plumb in an option to set
458 init_merge_options(&o
);
460 work
= write_tree_from_memory(&o
);
462 ret
= reset_tree(new->commit
->tree
, opts
, 1);
465 o
.ancestor
= old
->name
;
466 o
.branch1
= new->name
;
468 merge_trees(&o
, new->commit
->tree
, work
,
469 old
->commit
->tree
, &result
);
470 ret
= reset_tree(new->commit
->tree
, opts
, 0);
476 if (write_cache(newfd
, active_cache
, active_nr
) ||
477 commit_locked_index(lock_file
))
478 die(_("unable to write new index file"));
480 if (!opts
->force
&& !opts
->quiet
)
481 show_local_changes(&new->commit
->object
, &opts
->diff_options
);
486 static void report_tracking(struct branch_info
*new)
488 struct strbuf sb
= STRBUF_INIT
;
489 struct branch
*branch
= branch_get(new->name
);
491 if (!format_tracking_info(branch
, &sb
))
493 fputs(sb
.buf
, stdout
);
497 static void detach_advice(const char *old_path
, const char *new_name
)
500 "Note: checking out '%s'.\n\n"
501 "You are in 'detached HEAD' state. You can look around, make experimental\n"
502 "changes and commit them, and you can discard any commits you make in this\n"
503 "state without impacting any branches by performing another checkout.\n\n"
504 "If you want to create a new branch to retain commits you create, you may\n"
505 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
506 " git checkout -b new_branch_name\n\n";
508 fprintf(stderr
, fmt
, new_name
);
511 static void update_refs_for_switch(struct checkout_opts
*opts
,
512 struct branch_info
*old
,
513 struct branch_info
*new)
515 struct strbuf msg
= STRBUF_INIT
;
516 const char *old_desc
;
517 if (opts
->new_branch
) {
518 if (opts
->new_orphan_branch
) {
519 if (opts
->new_branch_log
&& !log_all_ref_updates
) {
521 char log_file
[PATH_MAX
];
522 char *ref_name
= mkpath("refs/heads/%s", opts
->new_orphan_branch
);
524 temp
= log_all_ref_updates
;
525 log_all_ref_updates
= 1;
526 if (log_ref_setup(ref_name
, log_file
, sizeof(log_file
))) {
527 fprintf(stderr
, _("Can not do reflog for '%s'\n"),
528 opts
->new_orphan_branch
);
529 log_all_ref_updates
= temp
;
532 log_all_ref_updates
= temp
;
536 create_branch(old
->name
, opts
->new_branch
, new->name
,
537 opts
->new_branch_force
? 1 : 0,
538 opts
->new_branch_log
, opts
->track
);
539 new->name
= opts
->new_branch
;
540 setup_branch_path(new);
543 old_desc
= old
->name
;
544 if (!old_desc
&& old
->commit
)
545 old_desc
= sha1_to_hex(old
->commit
->object
.sha1
);
546 strbuf_addf(&msg
, "checkout: moving from %s to %s",
547 old_desc
? old_desc
: "(invalid)", new->name
);
549 if (!strcmp(new->name
, "HEAD") && !new->path
&& !opts
->force_detach
) {
551 } else if (opts
->force_detach
|| !new->path
) { /* No longer on any branch. */
552 update_ref(msg
.buf
, "HEAD", new->commit
->object
.sha1
, NULL
,
553 REF_NODEREF
, DIE_ON_ERR
);
555 if (old
->path
&& advice_detached_head
)
556 detach_advice(old
->path
, new->name
);
557 describe_detached_head(_("HEAD is now at"), new->commit
);
559 } else if (new->path
) { /* Switch branches. */
560 create_symref("HEAD", new->path
, msg
.buf
);
562 if (old
->path
&& !strcmp(new->path
, old
->path
)) {
563 fprintf(stderr
, _("Already on '%s'\n"),
565 } else if (opts
->new_branch
) {
566 if (opts
->branch_exists
)
567 fprintf(stderr
, _("Switched to and reset branch '%s'\n"), new->name
);
569 fprintf(stderr
, _("Switched to a new branch '%s'\n"), new->name
);
571 fprintf(stderr
, _("Switched to branch '%s'\n"),
575 if (old
->path
&& old
->name
) {
576 char log_file
[PATH_MAX
], ref_file
[PATH_MAX
];
578 git_snpath(log_file
, sizeof(log_file
), "logs/%s", old
->path
);
579 git_snpath(ref_file
, sizeof(ref_file
), "%s", old
->path
);
580 if (!file_exists(ref_file
) && file_exists(log_file
))
581 remove_path(log_file
);
584 remove_branch_state();
585 strbuf_release(&msg
);
587 (new->path
|| (!opts
->force_detach
&& !strcmp(new->name
, "HEAD"))))
588 report_tracking(new);
591 static int add_pending_uninteresting_ref(const char *refname
,
592 const unsigned char *sha1
,
593 int flags
, void *cb_data
)
595 add_pending_sha1(cb_data
, refname
, sha1
, flags
| UNINTERESTING
);
599 static void describe_one_orphan(struct strbuf
*sb
, struct commit
*commit
)
601 parse_commit(commit
);
602 strbuf_addstr(sb
, " ");
604 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
));
605 strbuf_addch(sb
, ' ');
606 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, sb
);
607 strbuf_addch(sb
, '\n');
610 #define ORPHAN_CUTOFF 4
611 static void suggest_reattach(struct commit
*commit
, struct rev_info
*revs
)
613 struct commit
*c
, *last
= NULL
;
614 struct strbuf sb
= STRBUF_INIT
;
616 while ((c
= get_revision(revs
)) != NULL
) {
617 if (lost
< ORPHAN_CUTOFF
)
618 describe_one_orphan(&sb
, c
);
622 if (ORPHAN_CUTOFF
< lost
) {
623 int more
= lost
- ORPHAN_CUTOFF
;
625 describe_one_orphan(&sb
, last
);
627 strbuf_addf(&sb
, _(" ... and %d more.\n"), more
);
632 /* The singular version */
633 "Warning: you are leaving %d commit behind, "
635 "any of your branches:\n\n"
637 "If you want to keep it by creating a new branch, "
638 "this may be a good time\nto do so with:\n\n"
639 " git branch new_branch_name %s\n\n",
640 /* The plural version */
641 "Warning: you are leaving %d commits behind, "
643 "any of your branches:\n\n"
645 "If you want to keep them by creating a new branch, "
646 "this may be a good time\nto do so with:\n\n"
647 " git branch new_branch_name %s\n\n",
648 /* Give ngettext() the count */
652 sha1_to_hex(commit
->object
.sha1
));
657 * We are about to leave commit that was at the tip of a detached
658 * HEAD. If it is not reachable from any ref, this is the last chance
659 * for the user to do so without resorting to reflog.
661 static void orphaned_commit_warning(struct commit
*commit
)
663 struct rev_info revs
;
664 struct object
*object
= &commit
->object
;
665 struct object_array refs
;
668 init_revisions(&revs
, NULL
);
669 setup_revisions(0, NULL
, &revs
, NULL
);
671 object
->flags
&= ~UNINTERESTING
;
672 add_pending_object(&revs
, object
, sha1_to_hex(object
->sha1
));
674 for_each_ref(add_pending_uninteresting_ref
, &revs
);
677 revs
.leak_pending
= 1;
679 if (prepare_revision_walk(&revs
))
680 die(_("internal error in revision walk"));
681 if (!(commit
->object
.flags
& UNINTERESTING
))
682 suggest_reattach(commit
, &revs
);
684 describe_detached_head(_("Previous HEAD position was"), commit
);
686 for (i
= 0; i
< refs
.nr
; i
++) {
687 struct object
*o
= refs
.objects
[i
].item
;
688 struct commit
*c
= lookup_commit_reference_gently(o
->sha1
, 1);
690 clear_commit_marks(c
, ALL_REV_FLAGS
);
695 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
698 struct branch_info old
;
699 unsigned char rev
[20];
701 memset(&old
, 0, sizeof(old
));
702 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
703 old
.commit
= lookup_commit_reference_gently(rev
, 1);
704 if (!(flag
& REF_ISSYMREF
))
707 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
708 old
.name
= old
.path
+ strlen("refs/heads/");
712 new->commit
= old
.commit
;
714 die(_("You are on a branch yet to be born"));
715 parse_commit(new->commit
);
718 ret
= merge_working_tree(opts
, &old
, new);
722 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
723 orphaned_commit_warning(old
.commit
);
725 update_refs_for_switch(opts
, &old
, new);
727 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
728 return ret
|| opts
->writeout_error
;
731 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
733 if (!strcmp(var
, "diff.ignoresubmodules")) {
734 struct checkout_opts
*opts
= cb
;
735 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
739 if (!prefixcmp(var
, "submodule."))
740 return parse_submodule_config_option(var
, value
);
742 return git_xmerge_config(var
, value
, NULL
);
745 static int interactive_checkout(const char *revision
, const char **pathspec
,
746 struct checkout_opts
*opts
)
748 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
751 struct tracking_name_data
{
757 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
758 int flags
, void *cb_data
)
760 struct tracking_name_data
*cb
= cb_data
;
763 if (prefixcmp(refname
, "refs/remotes/"))
765 slash
= strchr(refname
+ 13, '/');
766 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
772 cb
->remote
= xstrdup(refname
);
776 static const char *unique_tracking_name(const char *name
)
778 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
780 for_each_ref(check_tracking_name
, &cb_data
);
782 return cb_data
.remote
;
783 free(cb_data
.remote
);
787 static int parse_branchname_arg(int argc
, const char **argv
,
788 int dwim_new_local_branch_ok
,
789 struct branch_info
*new,
790 struct tree
**source_tree
,
791 unsigned char rev
[20],
792 const char **new_branch
)
795 unsigned char branch_rev
[20];
800 * case 1: git checkout <ref> -- [<paths>]
802 * <ref> must be a valid tree, everything after the '--' must be
805 * case 2: git checkout -- [<paths>]
807 * everything after the '--' must be paths.
809 * case 3: git checkout <something> [<paths>]
811 * With no paths, if <something> is a commit, that is to
812 * switch to the branch or detach HEAD at it. As a special case,
813 * if <something> is A...B (missing A or B means HEAD but you can
814 * omit at most one side), and if there is a unique merge base
815 * between A and B, A...B names that merge base.
817 * With no paths, if <something> is _not_ a commit, no -t nor -b
818 * was given, and there is a tracking branch whose name is
819 * <something> in one and only one remote, then this is a short-hand
820 * to fork local <something> from that remote-tracking branch.
822 * Otherwise <something> shall not be ambiguous.
823 * - If it's *only* a reference, treat it like case (1).
824 * - If it's only a path, treat it like case (2).
831 if (!strcmp(argv
[0], "--")) /* case (2) */
835 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
837 if (!strcmp(arg
, "-"))
840 if (get_sha1_mb(arg
, rev
)) {
841 if (has_dash_dash
) /* case (1) */
842 die(_("invalid reference: %s"), arg
);
843 if (dwim_new_local_branch_ok
&&
844 !check_filename(NULL
, arg
) &&
846 const char *remote
= unique_tracking_name(arg
);
847 if (!remote
|| get_sha1(remote
, rev
))
851 /* DWIMmed to create local branch */
857 /* we can't end up being in (2) anymore, eat the argument */
863 setup_branch_path(new);
865 if (check_ref_format(new->path
) == CHECK_REF_FORMAT_OK
&&
866 resolve_ref(new->path
, branch_rev
, 1, NULL
))
867 hashcpy(rev
, branch_rev
);
869 new->path
= NULL
; /* not an existing branch */
871 new->commit
= lookup_commit_reference_gently(rev
, 1);
874 *source_tree
= parse_tree_indirect(rev
);
876 parse_commit(new->commit
);
877 *source_tree
= new->commit
->tree
;
880 if (!*source_tree
) /* case (1): want a tree */
881 die(_("reference is not a tree: %s"), arg
);
882 if (!has_dash_dash
) {/* case (3 -> 1) */
884 * Do not complain the most common case
885 * git checkout branch
886 * even if there happen to be a file called 'branch';
887 * it would be extremely annoying.
890 verify_non_filename(NULL
, arg
);
900 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
902 struct checkout_opts opts
;
903 unsigned char rev
[20];
904 struct branch_info
new;
905 struct tree
*source_tree
= NULL
;
906 char *conflict_style
= NULL
;
908 int dwim_new_local_branch
= 1;
909 struct option options
[] = {
910 OPT__QUIET(&opts
.quiet
, "suppress progress reporting"),
911 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
912 "create and checkout a new branch"),
913 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
914 "create/reset and checkout a branch"),
915 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "create reflog for new branch"),
916 OPT_BOOLEAN(0, "detach", &opts
.force_detach
, "detach the HEAD at named commit"),
917 OPT_SET_INT('t', "track", &opts
.track
, "set upstream info for new branch",
918 BRANCH_TRACK_EXPLICIT
),
919 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
920 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "checkout our version for unmerged files",
922 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "checkout their version for unmerged files",
924 OPT__FORCE(&opts
.force
, "force checkout (throw away local modifications)"),
925 OPT_BOOLEAN('m', "merge", &opts
.merge
, "perform a 3-way merge with the new branch"),
926 OPT_STRING(0, "conflict", &conflict_style
, "style",
927 "conflict style (merge or diff3)"),
928 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
929 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
930 "second guess 'git checkout no-such-branch'",
931 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
935 memset(&opts
, 0, sizeof(opts
));
936 memset(&new, 0, sizeof(new));
939 git_config(git_checkout_config
, &opts
);
941 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
943 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
944 PARSE_OPT_KEEP_DASHDASH
);
946 /* we can assume from now on new_branch = !new_branch_force */
947 if (opts
.new_branch
&& opts
.new_branch_force
)
948 die(_("-B cannot be used with -b"));
950 /* copy -B over to -b, so that we can just check the latter */
951 if (opts
.new_branch_force
)
952 opts
.new_branch
= opts
.new_branch_force
;
954 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
955 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
956 || opts
.force_detach
))
957 die (_("--patch is incompatible with all other options"));
959 if (opts
.force_detach
&& (opts
.new_branch
|| opts
.new_orphan_branch
))
960 die(_("--detach cannot be used with -b/-B/--orphan"));
961 if (opts
.force_detach
&& 0 < opts
.track
)
962 die(_("--detach cannot be used with -t"));
964 /* --track without -b should DWIM */
965 if (0 < opts
.track
&& !opts
.new_branch
) {
966 const char *argv0
= argv
[0];
967 if (!argc
|| !strcmp(argv0
, "--"))
968 die (_("--track needs a branch name"));
969 if (!prefixcmp(argv0
, "refs/"))
971 if (!prefixcmp(argv0
, "remotes/"))
973 argv0
= strchr(argv0
, '/');
974 if (!argv0
|| !argv0
[1])
975 die (_("Missing branch name; try -b"));
976 opts
.new_branch
= argv0
+ 1;
979 if (opts
.new_orphan_branch
) {
981 die(_("--orphan and -b|-B are mutually exclusive"));
983 die(_("--orphan cannot be used with -t"));
984 opts
.new_branch
= opts
.new_orphan_branch
;
987 if (conflict_style
) {
988 opts
.merge
= 1; /* implied */
989 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
992 if (opts
.force
&& opts
.merge
)
993 die(_("git checkout: -f and -m are incompatible"));
996 * Extract branch name from command line arguments, so
997 * all that is left is pathspecs.
1001 * 1) git checkout <tree> -- [<paths>]
1002 * 2) git checkout -- [<paths>]
1003 * 3) git checkout <something> [<paths>]
1005 * including "last branch" syntax and DWIM-ery for names of
1006 * remote branches, erroring out for invalid or ambiguous cases.
1011 dwim_new_local_branch
&&
1012 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
1014 int n
= parse_branchname_arg(argc
, argv
, dwim_ok
,
1015 &new, &source_tree
, rev
, &opts
.new_branch
);
1020 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
1021 opts
.track
= git_branch_track
;
1024 const char **pathspec
= get_pathspec(prefix
, argv
);
1027 die(_("invalid path specification"));
1030 return interactive_checkout(new.name
, pathspec
, &opts
);
1032 /* Checkout paths */
1033 if (opts
.new_branch
) {
1035 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]);
1037 die(_("git checkout: updating paths is incompatible with switching branches."));
1041 if (opts
.force_detach
)
1042 die(_("git checkout: --detach does not take a path argument"));
1044 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
1045 die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
1047 return checkout_paths(source_tree
, pathspec
, &opts
);
1051 return interactive_checkout(new.name
, NULL
, &opts
);
1053 if (opts
.new_branch
) {
1054 struct strbuf buf
= STRBUF_INIT
;
1055 if (strbuf_check_branch_ref(&buf
, opts
.new_branch
))
1056 die(_("git checkout: we do not like '%s' as a branch name."),
1058 if (!get_sha1(buf
.buf
, rev
)) {
1059 opts
.branch_exists
= 1;
1060 if (!opts
.new_branch_force
)
1061 die(_("git checkout: branch %s already exists"),
1064 strbuf_release(&buf
);
1067 if (new.name
&& !new.commit
) {
1068 die(_("Cannot switch branch to a non-commit."));
1070 if (opts
.writeout_stage
)
1071 die(_("--ours/--theirs is incompatible with switching branches."));
1073 return switch_branches(&opts
, &new);