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"
22 #include "argv-array.h"
24 static const char * const checkout_usage
[] = {
25 "git checkout [options] <branch>",
26 "git checkout [options] [<branch>] -- <file>...",
30 struct checkout_opts
{
39 /* not set by parse_options */
42 const char *new_branch
;
43 const char *new_branch_force
;
44 const char *new_orphan_branch
;
46 enum branch_track track
;
47 struct diff_options diff_options
;
50 static int post_checkout_hook(struct commit
*old
, struct commit
*new,
53 return run_hook(NULL
, "post-checkout",
54 sha1_to_hex(old
? old
->object
.sha1
: null_sha1
),
55 sha1_to_hex(new ? new->object
.sha1
: null_sha1
),
56 changed
? "1" : "0", NULL
);
57 /* "new" can be NULL when checking out from the index before
62 static int update_some(const unsigned char *sha1
, const char *base
, int baselen
,
63 const char *pathname
, unsigned mode
, int stage
, void *context
)
66 struct cache_entry
*ce
;
69 return READ_TREE_RECURSIVE
;
71 len
= baselen
+ strlen(pathname
);
72 ce
= xcalloc(1, cache_entry_size(len
));
73 hashcpy(ce
->sha1
, sha1
);
74 memcpy(ce
->name
, base
, baselen
);
75 memcpy(ce
->name
+ baselen
, pathname
, len
- baselen
);
76 ce
->ce_flags
= create_ce_flags(len
, 0) | CE_UPDATE
;
77 ce
->ce_mode
= create_ce_mode(mode
);
78 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
82 static int read_tree_some(struct tree
*tree
, const char **pathspec
)
85 init_pathspec(&ps
, pathspec
);
86 read_tree_recursive(tree
, "", 0, 0, &ps
, update_some
, NULL
);
89 /* update the index with the given tree's info
90 * for all args, expanding wildcards, and exit
91 * with any non-zero return code.
96 static int skip_same_name(struct cache_entry
*ce
, int pos
)
98 while (++pos
< active_nr
&&
99 !strcmp(active_cache
[pos
]->name
, ce
->name
))
104 static int check_stage(int stage
, struct cache_entry
*ce
, int pos
)
106 while (pos
< active_nr
&&
107 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
108 if (ce_stage(active_cache
[pos
]) == stage
)
113 return error(_("path '%s' does not have our version"), ce
->name
);
115 return error(_("path '%s' does not have their version"), ce
->name
);
118 static int check_stages(unsigned stages
, struct cache_entry
*ce
, int pos
)
121 const char *name
= ce
->name
;
123 while (pos
< active_nr
) {
124 ce
= active_cache
[pos
];
125 if (strcmp(name
, ce
->name
))
127 seen
|= (1 << ce_stage(ce
));
130 if ((stages
& seen
) != stages
)
131 return error(_("path '%s' does not have all necessary versions"),
136 static int checkout_stage(int stage
, struct cache_entry
*ce
, int pos
,
137 struct checkout
*state
)
139 while (pos
< active_nr
&&
140 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
141 if (ce_stage(active_cache
[pos
]) == stage
)
142 return checkout_entry(active_cache
[pos
], state
, NULL
);
146 return error(_("path '%s' does not have our version"), ce
->name
);
148 return error(_("path '%s' does not have their version"), ce
->name
);
151 static int checkout_merged(int pos
, struct checkout
*state
)
153 struct cache_entry
*ce
= active_cache
[pos
];
154 const char *path
= ce
->name
;
155 mmfile_t ancestor
, ours
, theirs
;
157 unsigned char sha1
[20];
158 mmbuffer_t result_buf
;
159 unsigned char threeway
[3][20];
162 memset(threeway
, 0, sizeof(threeway
));
163 while (pos
< active_nr
) {
165 stage
= ce_stage(ce
);
166 if (!stage
|| strcmp(path
, ce
->name
))
168 hashcpy(threeway
[stage
- 1], ce
->sha1
);
170 mode
= create_ce_mode(ce
->ce_mode
);
172 ce
= active_cache
[pos
];
174 if (is_null_sha1(threeway
[1]) || is_null_sha1(threeway
[2]))
175 return error(_("path '%s' does not have necessary versions"), path
);
177 read_mmblob(&ancestor
, threeway
[0]);
178 read_mmblob(&ours
, threeway
[1]);
179 read_mmblob(&theirs
, threeway
[2]);
182 * NEEDSWORK: re-create conflicts from merges with
183 * merge.renormalize set, too
185 status
= ll_merge(&result_buf
, path
, &ancestor
, "base",
186 &ours
, "ours", &theirs
, "theirs", NULL
);
190 if (status
< 0 || !result_buf
.ptr
) {
191 free(result_buf
.ptr
);
192 return error(_("path '%s': cannot merge"), path
);
197 * There is absolutely no reason to write this as a blob object
198 * and create a phony cache entry just to leak. This hack is
199 * primarily to get to the write_entry() machinery that massages
200 * the contents to work-tree format and writes out which only
201 * allows it for a cache entry. The code in write_entry() needs
202 * to be refactored to allow us to feed a <buffer, size, mode>
203 * instead of a cache entry. Such a refactoring would help
204 * merge_recursive as well (it also writes the merge result to the
205 * object database even when it may contain conflicts).
207 if (write_sha1_file(result_buf
.ptr
, result_buf
.size
,
209 die(_("Unable to add merge result for '%s'"), path
);
210 ce
= make_cache_entry(mode
, sha1
, path
, 2, 0);
212 die(_("make_cache_entry failed for path '%s'"), path
);
213 status
= checkout_entry(ce
, state
, NULL
);
217 static int checkout_paths(struct tree
*source_tree
, const char **pathspec
,
218 const char *prefix
, struct checkout_opts
*opts
)
221 struct checkout state
;
222 static char *ps_matched
;
223 unsigned char rev
[20];
227 int stage
= opts
->writeout_stage
;
228 int merge
= opts
->merge
;
230 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
232 newfd
= hold_locked_index(lock_file
, 1);
233 if (read_cache_preload(pathspec
) < 0)
234 return error(_("corrupt index file"));
237 read_tree_some(source_tree
, pathspec
);
239 for (pos
= 0; pathspec
[pos
]; pos
++)
241 ps_matched
= xcalloc(1, pos
);
243 for (pos
= 0; pos
< active_nr
; pos
++) {
244 struct cache_entry
*ce
= active_cache
[pos
];
245 if (source_tree
&& !(ce
->ce_flags
& CE_UPDATE
))
247 match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, ps_matched
);
250 if (report_path_error(ps_matched
, pathspec
, prefix
))
253 /* "checkout -m path" to recreate conflicted state */
255 unmerge_cache(pathspec
);
257 /* Any unmerged paths? */
258 for (pos
= 0; pos
< active_nr
; pos
++) {
259 struct cache_entry
*ce
= active_cache
[pos
];
260 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
264 warning(_("path '%s' is unmerged"), ce
->name
);
266 errs
|= check_stage(stage
, ce
, pos
);
267 } else if (opts
->merge
) {
268 errs
|= check_stages((1<<2) | (1<<3), ce
, pos
);
271 error(_("path '%s' is unmerged"), ce
->name
);
273 pos
= skip_same_name(ce
, pos
) - 1;
279 /* Now we are committed to check them out */
280 memset(&state
, 0, sizeof(state
));
282 state
.refresh_cache
= 1;
283 for (pos
= 0; pos
< active_nr
; pos
++) {
284 struct cache_entry
*ce
= active_cache
[pos
];
285 if (source_tree
&& !(ce
->ce_flags
& CE_UPDATE
))
287 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
289 errs
|= checkout_entry(ce
, &state
, NULL
);
293 errs
|= checkout_stage(stage
, ce
, pos
, &state
);
295 errs
|= checkout_merged(pos
, &state
);
296 pos
= skip_same_name(ce
, pos
) - 1;
300 if (write_cache(newfd
, active_cache
, active_nr
) ||
301 commit_locked_index(lock_file
))
302 die(_("unable to write new index file"));
304 read_ref_full("HEAD", rev
, 0, &flag
);
305 head
= lookup_commit_reference_gently(rev
, 1);
307 errs
|= post_checkout_hook(head
, head
, 0);
311 static void show_local_changes(struct object
*head
, struct diff_options
*opts
)
314 /* I think we want full paths, even if we're in a subdirectory. */
315 init_revisions(&rev
, NULL
);
316 rev
.diffopt
.flags
= opts
->flags
;
317 rev
.diffopt
.output_format
|= DIFF_FORMAT_NAME_STATUS
;
318 diff_setup_done(&rev
.diffopt
);
319 add_pending_object(&rev
, head
, NULL
);
320 run_diff_index(&rev
, 0);
323 static void describe_detached_head(const char *msg
, struct commit
*commit
)
325 struct strbuf sb
= STRBUF_INIT
;
326 parse_commit(commit
);
327 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, &sb
);
328 fprintf(stderr
, "%s %s... %s\n", msg
,
329 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
333 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
335 struct unpack_trees_options opts
;
336 struct tree_desc tree_desc
;
338 memset(&opts
, 0, sizeof(opts
));
340 opts
.update
= worktree
;
341 opts
.skip_unmerged
= !worktree
;
344 opts
.fn
= oneway_merge
;
345 opts
.verbose_update
= !o
->quiet
;
346 opts
.src_index
= &the_index
;
347 opts
.dst_index
= &the_index
;
349 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
350 switch (unpack_trees(1, &tree_desc
, &opts
)) {
352 o
->writeout_error
= 1;
354 * We return 0 nevertheless, as the index is all right
355 * and more importantly we have made best efforts to
356 * update paths in the work tree, and we cannot revert
367 const char *name
; /* The short name used */
368 const char *path
; /* The full name of a real branch */
369 struct commit
*commit
; /* The named commit */
372 static void setup_branch_path(struct branch_info
*branch
)
374 struct strbuf buf
= STRBUF_INIT
;
376 strbuf_branchname(&buf
, branch
->name
);
377 if (strcmp(buf
.buf
, branch
->name
))
378 branch
->name
= xstrdup(buf
.buf
);
379 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
380 branch
->path
= strbuf_detach(&buf
, NULL
);
383 static int merge_working_tree(struct checkout_opts
*opts
,
384 struct branch_info
*old
, struct branch_info
*new)
387 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
388 int newfd
= hold_locked_index(lock_file
, 1);
390 if (read_cache_preload(NULL
) < 0)
391 return error(_("corrupt index file"));
393 resolve_undo_clear();
395 ret
= reset_tree(new->commit
->tree
, opts
, 1);
399 struct tree_desc trees
[2];
401 struct unpack_trees_options topts
;
403 memset(&topts
, 0, sizeof(topts
));
405 topts
.src_index
= &the_index
;
406 topts
.dst_index
= &the_index
;
408 setup_unpack_trees_porcelain(&topts
, "checkout");
410 refresh_cache(REFRESH_QUIET
);
412 if (unmerged_cache()) {
413 error(_("you need to resolve your current index first"));
417 /* 2-way merge to the new branch */
418 topts
.initial_checkout
= is_cache_unborn();
421 topts
.gently
= opts
->merge
&& old
->commit
;
422 topts
.verbose_update
= !opts
->quiet
;
423 topts
.fn
= twoway_merge
;
424 if (opts
->overwrite_ignore
) {
425 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
426 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
427 setup_standard_excludes(topts
.dir
);
429 tree
= parse_tree_indirect(old
->commit
?
430 old
->commit
->object
.sha1
:
431 EMPTY_TREE_SHA1_BIN
);
432 init_tree_desc(&trees
[0], tree
->buffer
, tree
->size
);
433 tree
= parse_tree_indirect(new->commit
->object
.sha1
);
434 init_tree_desc(&trees
[1], tree
->buffer
, tree
->size
);
436 ret
= unpack_trees(2, trees
, &topts
);
439 * Unpack couldn't do a trivial merge; either
440 * give up or do a real merge, depending on
441 * whether the merge flag was used.
445 struct merge_options o
;
450 * Without old->commit, the below is the same as
451 * the two-tree unpack we already tried and failed.
456 /* Do more real merge */
459 * We update the index fully, then write the
460 * tree from the index, then merge the new
461 * branch with the current tree, with the old
462 * branch as the base. Then we reset the index
463 * (but not the working tree) to the new
464 * branch, leaving the working tree as the
465 * merged version, but skipping unmerged
466 * entries in the index.
469 add_files_to_cache(NULL
, NULL
, 0);
471 * NEEDSWORK: carrying over local changes
472 * when branches have different end-of-line
473 * normalization (or clean+smudge rules) is
474 * a pain; plumb in an option to set
477 init_merge_options(&o
);
479 work
= write_tree_from_memory(&o
);
481 ret
= reset_tree(new->commit
->tree
, opts
, 1);
484 o
.ancestor
= old
->name
;
485 o
.branch1
= new->name
;
487 merge_trees(&o
, new->commit
->tree
, work
,
488 old
->commit
->tree
, &result
);
489 ret
= reset_tree(new->commit
->tree
, opts
, 0);
495 if (write_cache(newfd
, active_cache
, active_nr
) ||
496 commit_locked_index(lock_file
))
497 die(_("unable to write new index file"));
499 if (!opts
->force
&& !opts
->quiet
)
500 show_local_changes(&new->commit
->object
, &opts
->diff_options
);
505 static void report_tracking(struct branch_info
*new)
507 struct strbuf sb
= STRBUF_INIT
;
508 struct branch
*branch
= branch_get(new->name
);
510 if (!format_tracking_info(branch
, &sb
))
512 fputs(sb
.buf
, stdout
);
516 static void detach_advice(const char *old_path
, const char *new_name
)
519 "Note: checking out '%s'.\n\n"
520 "You are in 'detached HEAD' state. You can look around, make experimental\n"
521 "changes and commit them, and you can discard any commits you make in this\n"
522 "state without impacting any branches by performing another checkout.\n\n"
523 "If you want to create a new branch to retain commits you create, you may\n"
524 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
525 " git checkout -b new_branch_name\n\n";
527 fprintf(stderr
, fmt
, new_name
);
530 static void update_refs_for_switch(struct checkout_opts
*opts
,
531 struct branch_info
*old
,
532 struct branch_info
*new)
534 struct strbuf msg
= STRBUF_INIT
;
535 const char *old_desc
;
536 if (opts
->new_branch
) {
537 if (opts
->new_orphan_branch
) {
538 if (opts
->new_branch_log
&& !log_all_ref_updates
) {
540 char log_file
[PATH_MAX
];
541 char *ref_name
= mkpath("refs/heads/%s", opts
->new_orphan_branch
);
543 temp
= log_all_ref_updates
;
544 log_all_ref_updates
= 1;
545 if (log_ref_setup(ref_name
, log_file
, sizeof(log_file
))) {
546 fprintf(stderr
, _("Can not do reflog for '%s'\n"),
547 opts
->new_orphan_branch
);
548 log_all_ref_updates
= temp
;
551 log_all_ref_updates
= temp
;
555 create_branch(old
->name
, opts
->new_branch
, new->name
,
556 opts
->new_branch_force
? 1 : 0,
557 opts
->new_branch_log
,
558 opts
->new_branch_force
? 1 : 0,
560 new->name
= opts
->new_branch
;
561 setup_branch_path(new);
564 old_desc
= old
->name
;
565 if (!old_desc
&& old
->commit
)
566 old_desc
= sha1_to_hex(old
->commit
->object
.sha1
);
567 strbuf_addf(&msg
, "checkout: moving from %s to %s",
568 old_desc
? old_desc
: "(invalid)", new->name
);
570 if (!strcmp(new->name
, "HEAD") && !new->path
&& !opts
->force_detach
) {
572 } else if (opts
->force_detach
|| !new->path
) { /* No longer on any branch. */
573 update_ref(msg
.buf
, "HEAD", new->commit
->object
.sha1
, NULL
,
574 REF_NODEREF
, DIE_ON_ERR
);
576 if (old
->path
&& advice_detached_head
)
577 detach_advice(old
->path
, new->name
);
578 describe_detached_head(_("HEAD is now at"), new->commit
);
580 } else if (new->path
) { /* Switch branches. */
581 create_symref("HEAD", new->path
, msg
.buf
);
583 if (old
->path
&& !strcmp(new->path
, old
->path
)) {
584 if (opts
->new_branch_force
)
585 fprintf(stderr
, _("Reset branch '%s'\n"),
588 fprintf(stderr
, _("Already on '%s'\n"),
590 } else if (opts
->new_branch
) {
591 if (opts
->branch_exists
)
592 fprintf(stderr
, _("Switched to and reset branch '%s'\n"), new->name
);
594 fprintf(stderr
, _("Switched to a new branch '%s'\n"), new->name
);
596 fprintf(stderr
, _("Switched to branch '%s'\n"),
600 if (old
->path
&& old
->name
) {
601 char log_file
[PATH_MAX
], ref_file
[PATH_MAX
];
603 git_snpath(log_file
, sizeof(log_file
), "logs/%s", old
->path
);
604 git_snpath(ref_file
, sizeof(ref_file
), "%s", old
->path
);
605 if (!file_exists(ref_file
) && file_exists(log_file
))
606 remove_path(log_file
);
609 remove_branch_state();
610 strbuf_release(&msg
);
612 (new->path
|| (!opts
->force_detach
&& !strcmp(new->name
, "HEAD"))))
613 report_tracking(new);
616 static int add_pending_uninteresting_ref(const char *refname
,
617 const unsigned char *sha1
,
618 int flags
, void *cb_data
)
620 add_pending_sha1(cb_data
, refname
, sha1
, flags
| UNINTERESTING
);
624 static void describe_one_orphan(struct strbuf
*sb
, struct commit
*commit
)
626 parse_commit(commit
);
627 strbuf_addstr(sb
, " ");
629 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
));
630 strbuf_addch(sb
, ' ');
631 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, sb
);
632 strbuf_addch(sb
, '\n');
635 #define ORPHAN_CUTOFF 4
636 static void suggest_reattach(struct commit
*commit
, struct rev_info
*revs
)
638 struct commit
*c
, *last
= NULL
;
639 struct strbuf sb
= STRBUF_INIT
;
641 while ((c
= get_revision(revs
)) != NULL
) {
642 if (lost
< ORPHAN_CUTOFF
)
643 describe_one_orphan(&sb
, c
);
647 if (ORPHAN_CUTOFF
< lost
) {
648 int more
= lost
- ORPHAN_CUTOFF
;
650 describe_one_orphan(&sb
, last
);
652 strbuf_addf(&sb
, _(" ... and %d more.\n"), more
);
657 /* The singular version */
658 "Warning: you are leaving %d commit behind, "
660 "any of your branches:\n\n"
662 /* The plural version */
663 "Warning: you are leaving %d commits behind, "
665 "any of your branches:\n\n"
667 /* Give ngettext() the count */
673 if (advice_detached_head
)
676 "If you want to keep them by creating a new branch, "
677 "this may be a good time\nto do so with:\n\n"
678 " git branch new_branch_name %s\n\n"),
679 sha1_to_hex(commit
->object
.sha1
));
683 * We are about to leave commit that was at the tip of a detached
684 * HEAD. If it is not reachable from any ref, this is the last chance
685 * for the user to do so without resorting to reflog.
687 static void orphaned_commit_warning(struct commit
*commit
)
689 struct rev_info revs
;
690 struct object
*object
= &commit
->object
;
691 struct object_array refs
;
693 init_revisions(&revs
, NULL
);
694 setup_revisions(0, NULL
, &revs
, NULL
);
696 object
->flags
&= ~UNINTERESTING
;
697 add_pending_object(&revs
, object
, sha1_to_hex(object
->sha1
));
699 for_each_ref(add_pending_uninteresting_ref
, &revs
);
702 revs
.leak_pending
= 1;
704 if (prepare_revision_walk(&revs
))
705 die(_("internal error in revision walk"));
706 if (!(commit
->object
.flags
& UNINTERESTING
))
707 suggest_reattach(commit
, &revs
);
709 describe_detached_head(_("Previous HEAD position was"), commit
);
711 clear_commit_marks_for_object_array(&refs
, ALL_REV_FLAGS
);
715 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
718 struct branch_info old
;
720 unsigned char rev
[20];
722 memset(&old
, 0, sizeof(old
));
723 old
.path
= path_to_free
= resolve_refdup("HEAD", rev
, 0, &flag
);
724 old
.commit
= lookup_commit_reference_gently(rev
, 1);
725 if (!(flag
& REF_ISSYMREF
))
728 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
729 old
.name
= old
.path
+ strlen("refs/heads/");
733 new->commit
= old
.commit
;
735 die(_("You are on a branch yet to be born"));
736 parse_commit(new->commit
);
739 ret
= merge_working_tree(opts
, &old
, new);
745 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
746 orphaned_commit_warning(old
.commit
);
748 update_refs_for_switch(opts
, &old
, new);
750 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
752 return ret
|| opts
->writeout_error
;
755 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
757 if (!strcmp(var
, "diff.ignoresubmodules")) {
758 struct checkout_opts
*opts
= cb
;
759 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
763 if (!prefixcmp(var
, "submodule."))
764 return parse_submodule_config_option(var
, value
);
766 return git_xmerge_config(var
, value
, NULL
);
769 static int interactive_checkout(const char *revision
, const char **pathspec
,
770 struct checkout_opts
*opts
)
772 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
775 struct tracking_name_data
{
781 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
782 int flags
, void *cb_data
)
784 struct tracking_name_data
*cb
= cb_data
;
787 if (prefixcmp(refname
, "refs/remotes/"))
789 slash
= strchr(refname
+ 13, '/');
790 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
796 cb
->remote
= xstrdup(refname
);
800 static const char *unique_tracking_name(const char *name
)
802 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
804 for_each_ref(check_tracking_name
, &cb_data
);
806 return cb_data
.remote
;
807 free(cb_data
.remote
);
811 static int parse_branchname_arg(int argc
, const char **argv
,
812 int dwim_new_local_branch_ok
,
813 struct branch_info
*new,
814 struct tree
**source_tree
,
815 unsigned char rev
[20],
816 const char **new_branch
)
819 unsigned char branch_rev
[20];
824 * case 1: git checkout <ref> -- [<paths>]
826 * <ref> must be a valid tree, everything after the '--' must be
829 * case 2: git checkout -- [<paths>]
831 * everything after the '--' must be paths.
833 * case 3: git checkout <something> [<paths>]
835 * With no paths, if <something> is a commit, that is to
836 * switch to the branch or detach HEAD at it. As a special case,
837 * if <something> is A...B (missing A or B means HEAD but you can
838 * omit at most one side), and if there is a unique merge base
839 * between A and B, A...B names that merge base.
841 * With no paths, if <something> is _not_ a commit, no -t nor -b
842 * was given, and there is a tracking branch whose name is
843 * <something> in one and only one remote, then this is a short-hand
844 * to fork local <something> from that remote-tracking branch.
846 * Otherwise <something> shall not be ambiguous.
847 * - If it's *only* a reference, treat it like case (1).
848 * - If it's only a path, treat it like case (2).
855 if (!strcmp(argv
[0], "--")) /* case (2) */
859 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
861 if (!strcmp(arg
, "-"))
864 if (get_sha1_mb(arg
, rev
)) {
865 if (has_dash_dash
) /* case (1) */
866 die(_("invalid reference: %s"), arg
);
867 if (dwim_new_local_branch_ok
&&
868 !check_filename(NULL
, arg
) &&
870 const char *remote
= unique_tracking_name(arg
);
871 if (!remote
|| get_sha1(remote
, rev
))
875 /* DWIMmed to create local branch */
881 /* we can't end up being in (2) anymore, eat the argument */
887 setup_branch_path(new);
889 if (!check_refname_format(new->path
, 0) &&
890 !read_ref(new->path
, branch_rev
))
891 hashcpy(rev
, branch_rev
);
893 new->path
= NULL
; /* not an existing branch */
895 new->commit
= lookup_commit_reference_gently(rev
, 1);
898 *source_tree
= parse_tree_indirect(rev
);
900 parse_commit(new->commit
);
901 *source_tree
= new->commit
->tree
;
904 if (!*source_tree
) /* case (1): want a tree */
905 die(_("reference is not a tree: %s"), arg
);
906 if (!has_dash_dash
) {/* case (3 -> 1) */
908 * Do not complain the most common case
909 * git checkout branch
910 * even if there happen to be a file called 'branch';
911 * it would be extremely annoying.
914 verify_non_filename(NULL
, arg
);
924 static int switch_unborn_to_new_branch(struct checkout_opts
*opts
)
927 struct strbuf branch_ref
= STRBUF_INIT
;
929 strbuf_addf(&branch_ref
, "refs/heads/%s", opts
->new_branch
);
930 status
= create_symref("HEAD", branch_ref
.buf
, "checkout -b");
931 strbuf_release(&branch_ref
);
935 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
937 struct checkout_opts opts
;
938 unsigned char rev
[20];
939 struct branch_info
new;
940 struct tree
*source_tree
= NULL
;
941 char *conflict_style
= NULL
;
943 int dwim_new_local_branch
= 1;
944 struct option options
[] = {
945 OPT__QUIET(&opts
.quiet
, "suppress progress reporting"),
946 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
947 "create and checkout a new branch"),
948 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
949 "create/reset and checkout a branch"),
950 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "create reflog for new branch"),
951 OPT_BOOLEAN(0, "detach", &opts
.force_detach
, "detach the HEAD at named commit"),
952 OPT_SET_INT('t', "track", &opts
.track
, "set upstream info for new branch",
953 BRANCH_TRACK_EXPLICIT
),
954 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
955 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "checkout our version for unmerged files",
957 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "checkout their version for unmerged files",
959 OPT__FORCE(&opts
.force
, "force checkout (throw away local modifications)"),
960 OPT_BOOLEAN('m', "merge", &opts
.merge
, "perform a 3-way merge with the new branch"),
961 OPT_BOOLEAN(0, "overwrite-ignore", &opts
.overwrite_ignore
, "update ignored files (default)"),
962 OPT_STRING(0, "conflict", &conflict_style
, "style",
963 "conflict style (merge or diff3)"),
964 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
965 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
966 "second guess 'git checkout no-such-branch'",
967 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
971 memset(&opts
, 0, sizeof(opts
));
972 memset(&new, 0, sizeof(new));
973 opts
.overwrite_ignore
= 1;
976 git_config(git_checkout_config
, &opts
);
978 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
980 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
981 PARSE_OPT_KEEP_DASHDASH
);
983 /* we can assume from now on new_branch = !new_branch_force */
984 if (opts
.new_branch
&& opts
.new_branch_force
)
985 die(_("-B cannot be used with -b"));
987 /* copy -B over to -b, so that we can just check the latter */
988 if (opts
.new_branch_force
)
989 opts
.new_branch
= opts
.new_branch_force
;
991 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
992 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
993 || opts
.force_detach
))
994 die (_("--patch is incompatible with all other options"));
996 if (opts
.force_detach
&& (opts
.new_branch
|| opts
.new_orphan_branch
))
997 die(_("--detach cannot be used with -b/-B/--orphan"));
998 if (opts
.force_detach
&& 0 < opts
.track
)
999 die(_("--detach cannot be used with -t"));
1001 /* --track without -b should DWIM */
1002 if (0 < opts
.track
&& !opts
.new_branch
) {
1003 const char *argv0
= argv
[0];
1004 if (!argc
|| !strcmp(argv0
, "--"))
1005 die (_("--track needs a branch name"));
1006 if (!prefixcmp(argv0
, "refs/"))
1008 if (!prefixcmp(argv0
, "remotes/"))
1010 argv0
= strchr(argv0
, '/');
1011 if (!argv0
|| !argv0
[1])
1012 die (_("Missing branch name; try -b"));
1013 opts
.new_branch
= argv0
+ 1;
1016 if (opts
.new_orphan_branch
) {
1017 if (opts
.new_branch
)
1018 die(_("--orphan and -b|-B are mutually exclusive"));
1020 die(_("--orphan cannot be used with -t"));
1021 opts
.new_branch
= opts
.new_orphan_branch
;
1024 if (conflict_style
) {
1025 opts
.merge
= 1; /* implied */
1026 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
1029 if (opts
.force
&& opts
.merge
)
1030 die(_("git checkout: -f and -m are incompatible"));
1033 * Extract branch name from command line arguments, so
1034 * all that is left is pathspecs.
1038 * 1) git checkout <tree> -- [<paths>]
1039 * 2) git checkout -- [<paths>]
1040 * 3) git checkout <something> [<paths>]
1042 * including "last branch" syntax and DWIM-ery for names of
1043 * remote branches, erroring out for invalid or ambiguous cases.
1048 dwim_new_local_branch
&&
1049 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
1051 int n
= parse_branchname_arg(argc
, argv
, dwim_ok
,
1052 &new, &source_tree
, rev
, &opts
.new_branch
);
1057 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
1058 opts
.track
= git_branch_track
;
1061 const char **pathspec
= get_pathspec(prefix
, argv
);
1064 die(_("invalid path specification"));
1067 return interactive_checkout(new.name
, pathspec
, &opts
);
1069 /* Checkout paths */
1070 if (opts
.new_branch
) {
1072 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]);
1074 die(_("git checkout: updating paths is incompatible with switching branches."));
1078 if (opts
.force_detach
)
1079 die(_("git checkout: --detach does not take a path argument"));
1081 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
1082 die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
1084 return checkout_paths(source_tree
, pathspec
, prefix
, &opts
);
1088 return interactive_checkout(new.name
, NULL
, &opts
);
1090 if (opts
.new_branch
) {
1091 struct strbuf buf
= STRBUF_INIT
;
1093 opts
.branch_exists
= validate_new_branchname(opts
.new_branch
, &buf
,
1094 !!opts
.new_branch_force
,
1095 !!opts
.new_branch_force
);
1097 strbuf_release(&buf
);
1100 if (new.name
&& !new.commit
) {
1101 die(_("Cannot switch branch to a non-commit."));
1103 if (opts
.writeout_stage
)
1104 die(_("--ours/--theirs is incompatible with switching branches."));
1107 unsigned char rev
[20];
1110 if (!read_ref_full("HEAD", rev
, 0, &flag
) &&
1111 (flag
& REF_ISSYMREF
) && is_null_sha1(rev
))
1112 return switch_unborn_to_new_branch(&opts
);
1114 return switch_branches(&opts
, &new);