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
;
667 init_revisions(&revs
, NULL
);
668 setup_revisions(0, NULL
, &revs
, NULL
);
670 object
->flags
&= ~UNINTERESTING
;
671 add_pending_object(&revs
, object
, sha1_to_hex(object
->sha1
));
673 for_each_ref(add_pending_uninteresting_ref
, &revs
);
676 revs
.leak_pending
= 1;
678 if (prepare_revision_walk(&revs
))
679 die(_("internal error in revision walk"));
680 if (!(commit
->object
.flags
& UNINTERESTING
))
681 suggest_reattach(commit
, &revs
);
683 describe_detached_head(_("Previous HEAD position was"), commit
);
685 clear_commit_marks_for_object_array(&refs
, ALL_REV_FLAGS
);
689 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
692 struct branch_info old
;
693 unsigned char rev
[20];
695 memset(&old
, 0, sizeof(old
));
696 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
697 old
.commit
= lookup_commit_reference_gently(rev
, 1);
698 if (!(flag
& REF_ISSYMREF
))
701 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
702 old
.name
= old
.path
+ strlen("refs/heads/");
706 new->commit
= old
.commit
;
708 die(_("You are on a branch yet to be born"));
709 parse_commit(new->commit
);
712 ret
= merge_working_tree(opts
, &old
, new);
716 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
717 orphaned_commit_warning(old
.commit
);
719 update_refs_for_switch(opts
, &old
, new);
721 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
722 return ret
|| opts
->writeout_error
;
725 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
727 if (!strcmp(var
, "diff.ignoresubmodules")) {
728 struct checkout_opts
*opts
= cb
;
729 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
733 if (!prefixcmp(var
, "submodule."))
734 return parse_submodule_config_option(var
, value
);
736 return git_xmerge_config(var
, value
, NULL
);
739 static int interactive_checkout(const char *revision
, const char **pathspec
,
740 struct checkout_opts
*opts
)
742 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
745 struct tracking_name_data
{
751 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
752 int flags
, void *cb_data
)
754 struct tracking_name_data
*cb
= cb_data
;
757 if (prefixcmp(refname
, "refs/remotes/"))
759 slash
= strchr(refname
+ 13, '/');
760 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
766 cb
->remote
= xstrdup(refname
);
770 static const char *unique_tracking_name(const char *name
)
772 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
774 for_each_ref(check_tracking_name
, &cb_data
);
776 return cb_data
.remote
;
777 free(cb_data
.remote
);
781 static int parse_branchname_arg(int argc
, const char **argv
,
782 int dwim_new_local_branch_ok
,
783 struct branch_info
*new,
784 struct tree
**source_tree
,
785 unsigned char rev
[20],
786 const char **new_branch
)
789 unsigned char branch_rev
[20];
794 * case 1: git checkout <ref> -- [<paths>]
796 * <ref> must be a valid tree, everything after the '--' must be
799 * case 2: git checkout -- [<paths>]
801 * everything after the '--' must be paths.
803 * case 3: git checkout <something> [<paths>]
805 * With no paths, if <something> is a commit, that is to
806 * switch to the branch or detach HEAD at it. As a special case,
807 * if <something> is A...B (missing A or B means HEAD but you can
808 * omit at most one side), and if there is a unique merge base
809 * between A and B, A...B names that merge base.
811 * With no paths, if <something> is _not_ a commit, no -t nor -b
812 * was given, and there is a tracking branch whose name is
813 * <something> in one and only one remote, then this is a short-hand
814 * to fork local <something> from that remote-tracking branch.
816 * Otherwise <something> shall not be ambiguous.
817 * - If it's *only* a reference, treat it like case (1).
818 * - If it's only a path, treat it like case (2).
825 if (!strcmp(argv
[0], "--")) /* case (2) */
829 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
831 if (!strcmp(arg
, "-"))
834 if (get_sha1_mb(arg
, rev
)) {
835 if (has_dash_dash
) /* case (1) */
836 die(_("invalid reference: %s"), arg
);
837 if (dwim_new_local_branch_ok
&&
838 !check_filename(NULL
, arg
) &&
840 const char *remote
= unique_tracking_name(arg
);
841 if (!remote
|| get_sha1(remote
, rev
))
845 /* DWIMmed to create local branch */
851 /* we can't end up being in (2) anymore, eat the argument */
857 setup_branch_path(new);
859 if (check_ref_format(new->path
) == CHECK_REF_FORMAT_OK
&&
860 resolve_ref(new->path
, branch_rev
, 1, NULL
))
861 hashcpy(rev
, branch_rev
);
863 new->path
= NULL
; /* not an existing branch */
865 new->commit
= lookup_commit_reference_gently(rev
, 1);
868 *source_tree
= parse_tree_indirect(rev
);
870 parse_commit(new->commit
);
871 *source_tree
= new->commit
->tree
;
874 if (!*source_tree
) /* case (1): want a tree */
875 die(_("reference is not a tree: %s"), arg
);
876 if (!has_dash_dash
) {/* case (3 -> 1) */
878 * Do not complain the most common case
879 * git checkout branch
880 * even if there happen to be a file called 'branch';
881 * it would be extremely annoying.
884 verify_non_filename(NULL
, arg
);
894 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
896 struct checkout_opts opts
;
897 unsigned char rev
[20];
898 struct branch_info
new;
899 struct tree
*source_tree
= NULL
;
900 char *conflict_style
= NULL
;
902 int dwim_new_local_branch
= 1;
903 struct option options
[] = {
904 OPT__QUIET(&opts
.quiet
, "suppress progress reporting"),
905 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
906 "create and checkout a new branch"),
907 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
908 "create/reset and checkout a branch"),
909 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "create reflog for new branch"),
910 OPT_BOOLEAN(0, "detach", &opts
.force_detach
, "detach the HEAD at named commit"),
911 OPT_SET_INT('t', "track", &opts
.track
, "set upstream info for new branch",
912 BRANCH_TRACK_EXPLICIT
),
913 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
914 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "checkout our version for unmerged files",
916 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "checkout their version for unmerged files",
918 OPT__FORCE(&opts
.force
, "force checkout (throw away local modifications)"),
919 OPT_BOOLEAN('m', "merge", &opts
.merge
, "perform a 3-way merge with the new branch"),
920 OPT_STRING(0, "conflict", &conflict_style
, "style",
921 "conflict style (merge or diff3)"),
922 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
923 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
924 "second guess 'git checkout no-such-branch'",
925 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
929 memset(&opts
, 0, sizeof(opts
));
930 memset(&new, 0, sizeof(new));
933 git_config(git_checkout_config
, &opts
);
935 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
937 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
938 PARSE_OPT_KEEP_DASHDASH
);
940 /* we can assume from now on new_branch = !new_branch_force */
941 if (opts
.new_branch
&& opts
.new_branch_force
)
942 die(_("-B cannot be used with -b"));
944 /* copy -B over to -b, so that we can just check the latter */
945 if (opts
.new_branch_force
)
946 opts
.new_branch
= opts
.new_branch_force
;
948 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
949 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
950 || opts
.force_detach
))
951 die (_("--patch is incompatible with all other options"));
953 if (opts
.force_detach
&& (opts
.new_branch
|| opts
.new_orphan_branch
))
954 die(_("--detach cannot be used with -b/-B/--orphan"));
955 if (opts
.force_detach
&& 0 < opts
.track
)
956 die(_("--detach cannot be used with -t"));
958 /* --track without -b should DWIM */
959 if (0 < opts
.track
&& !opts
.new_branch
) {
960 const char *argv0
= argv
[0];
961 if (!argc
|| !strcmp(argv0
, "--"))
962 die (_("--track needs a branch name"));
963 if (!prefixcmp(argv0
, "refs/"))
965 if (!prefixcmp(argv0
, "remotes/"))
967 argv0
= strchr(argv0
, '/');
968 if (!argv0
|| !argv0
[1])
969 die (_("Missing branch name; try -b"));
970 opts
.new_branch
= argv0
+ 1;
973 if (opts
.new_orphan_branch
) {
975 die(_("--orphan and -b|-B are mutually exclusive"));
977 die(_("--orphan cannot be used with -t"));
978 opts
.new_branch
= opts
.new_orphan_branch
;
981 if (conflict_style
) {
982 opts
.merge
= 1; /* implied */
983 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
986 if (opts
.force
&& opts
.merge
)
987 die(_("git checkout: -f and -m are incompatible"));
990 * Extract branch name from command line arguments, so
991 * all that is left is pathspecs.
995 * 1) git checkout <tree> -- [<paths>]
996 * 2) git checkout -- [<paths>]
997 * 3) git checkout <something> [<paths>]
999 * including "last branch" syntax and DWIM-ery for names of
1000 * remote branches, erroring out for invalid or ambiguous cases.
1005 dwim_new_local_branch
&&
1006 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
1008 int n
= parse_branchname_arg(argc
, argv
, dwim_ok
,
1009 &new, &source_tree
, rev
, &opts
.new_branch
);
1014 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
1015 opts
.track
= git_branch_track
;
1018 const char **pathspec
= get_pathspec(prefix
, argv
);
1021 die(_("invalid path specification"));
1024 return interactive_checkout(new.name
, pathspec
, &opts
);
1026 /* Checkout paths */
1027 if (opts
.new_branch
) {
1029 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]);
1031 die(_("git checkout: updating paths is incompatible with switching branches."));
1035 if (opts
.force_detach
)
1036 die(_("git checkout: --detach does not take a path argument"));
1038 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
1039 die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
1041 return checkout_paths(source_tree
, pathspec
, &opts
);
1045 return interactive_checkout(new.name
, NULL
, &opts
);
1047 if (opts
.new_branch
) {
1048 struct strbuf buf
= STRBUF_INIT
;
1049 if (strbuf_check_branch_ref(&buf
, opts
.new_branch
))
1050 die(_("git checkout: we do not like '%s' as a branch name."),
1052 if (!get_sha1(buf
.buf
, rev
)) {
1053 opts
.branch_exists
= 1;
1054 if (!opts
.new_branch_force
)
1055 die(_("git checkout: branch %s already exists"),
1058 strbuf_release(&buf
);
1061 if (new.name
&& !new.commit
) {
1062 die(_("Cannot switch branch to a non-commit."));
1064 if (opts
.writeout_stage
)
1065 die(_("--ours/--theirs is incompatible with switching branches."));
1067 return switch_branches(&opts
, &new);