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
{
38 /* not set by parse_options */
41 const char *new_branch
;
42 const char *new_branch_force
;
43 const char *new_orphan_branch
;
45 enum branch_track track
;
46 struct diff_options diff_options
;
49 static int post_checkout_hook(struct commit
*old
, struct commit
*new,
52 return run_hook(NULL
, "post-checkout",
53 sha1_to_hex(old
? old
->object
.sha1
: null_sha1
),
54 sha1_to_hex(new ? new->object
.sha1
: null_sha1
),
55 changed
? "1" : "0", NULL
);
56 /* "new" can be NULL when checking out from the index before
61 static int update_some(const unsigned char *sha1
, const char *base
, int baselen
,
62 const char *pathname
, unsigned mode
, int stage
, void *context
)
65 struct cache_entry
*ce
;
68 return READ_TREE_RECURSIVE
;
70 len
= baselen
+ strlen(pathname
);
71 ce
= xcalloc(1, cache_entry_size(len
));
72 hashcpy(ce
->sha1
, sha1
);
73 memcpy(ce
->name
, base
, baselen
);
74 memcpy(ce
->name
+ baselen
, pathname
, len
- baselen
);
75 ce
->ce_flags
= create_ce_flags(len
, 0) | CE_UPDATE
;
76 ce
->ce_mode
= create_ce_mode(mode
);
77 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
81 static int read_tree_some(struct tree
*tree
, const char **pathspec
)
84 init_pathspec(&ps
, pathspec
);
85 read_tree_recursive(tree
, "", 0, 0, &ps
, update_some
, NULL
);
88 /* update the index with the given tree's info
89 * for all args, expanding wildcards, and exit
90 * with any non-zero return code.
95 static int skip_same_name(struct cache_entry
*ce
, int pos
)
97 while (++pos
< active_nr
&&
98 !strcmp(active_cache
[pos
]->name
, ce
->name
))
103 static int check_stage(int stage
, struct cache_entry
*ce
, int pos
)
105 while (pos
< active_nr
&&
106 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
107 if (ce_stage(active_cache
[pos
]) == stage
)
112 return error(_("path '%s' does not have our version"), ce
->name
);
114 return error(_("path '%s' does not have their version"), ce
->name
);
117 static int check_all_stages(struct cache_entry
*ce
, int pos
)
119 if (ce_stage(ce
) != 1 ||
120 active_nr
<= pos
+ 2 ||
121 strcmp(active_cache
[pos
+1]->name
, ce
->name
) ||
122 ce_stage(active_cache
[pos
+1]) != 2 ||
123 strcmp(active_cache
[pos
+2]->name
, ce
->name
) ||
124 ce_stage(active_cache
[pos
+2]) != 3)
125 return error(_("path '%s' does not have all three versions"),
130 static int checkout_stage(int stage
, struct cache_entry
*ce
, int pos
,
131 struct checkout
*state
)
133 while (pos
< active_nr
&&
134 !strcmp(active_cache
[pos
]->name
, ce
->name
)) {
135 if (ce_stage(active_cache
[pos
]) == stage
)
136 return checkout_entry(active_cache
[pos
], state
, NULL
);
140 return error(_("path '%s' does not have our version"), ce
->name
);
142 return error(_("path '%s' does not have their version"), ce
->name
);
145 static int checkout_merged(int pos
, struct checkout
*state
)
147 struct cache_entry
*ce
= active_cache
[pos
];
148 const char *path
= ce
->name
;
149 mmfile_t ancestor
, ours
, theirs
;
151 unsigned char sha1
[20];
152 mmbuffer_t result_buf
;
154 if (ce_stage(ce
) != 1 ||
155 active_nr
<= pos
+ 2 ||
156 strcmp(active_cache
[pos
+1]->name
, path
) ||
157 ce_stage(active_cache
[pos
+1]) != 2 ||
158 strcmp(active_cache
[pos
+2]->name
, path
) ||
159 ce_stage(active_cache
[pos
+2]) != 3)
160 return error(_("path '%s' does not have all 3 versions"), path
);
162 read_mmblob(&ancestor
, active_cache
[pos
]->sha1
);
163 read_mmblob(&ours
, active_cache
[pos
+1]->sha1
);
164 read_mmblob(&theirs
, active_cache
[pos
+2]->sha1
);
167 * NEEDSWORK: re-create conflicts from merges with
168 * merge.renormalize set, too
170 status
= ll_merge(&result_buf
, path
, &ancestor
, "base",
171 &ours
, "ours", &theirs
, "theirs", NULL
);
175 if (status
< 0 || !result_buf
.ptr
) {
176 free(result_buf
.ptr
);
177 return error(_("path '%s': cannot merge"), path
);
182 * There is absolutely no reason to write this as a blob object
183 * and create a phony cache entry just to leak. This hack is
184 * primarily to get to the write_entry() machinery that massages
185 * the contents to work-tree format and writes out which only
186 * allows it for a cache entry. The code in write_entry() needs
187 * to be refactored to allow us to feed a <buffer, size, mode>
188 * instead of a cache entry. Such a refactoring would help
189 * merge_recursive as well (it also writes the merge result to the
190 * object database even when it may contain conflicts).
192 if (write_sha1_file(result_buf
.ptr
, result_buf
.size
,
194 die(_("Unable to add merge result for '%s'"), path
);
195 ce
= make_cache_entry(create_ce_mode(active_cache
[pos
+1]->ce_mode
),
199 die(_("make_cache_entry failed for path '%s'"), path
);
200 status
= checkout_entry(ce
, state
, NULL
);
204 static int checkout_paths(struct tree
*source_tree
, const char **pathspec
,
205 const char *prefix
, struct checkout_opts
*opts
)
208 struct checkout state
;
209 static char *ps_matched
;
210 unsigned char rev
[20];
214 int stage
= opts
->writeout_stage
;
215 int merge
= opts
->merge
;
217 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
219 newfd
= hold_locked_index(lock_file
, 1);
220 if (read_cache_preload(pathspec
) < 0)
221 return error(_("corrupt index file"));
224 read_tree_some(source_tree
, pathspec
);
226 for (pos
= 0; pathspec
[pos
]; pos
++)
228 ps_matched
= xcalloc(1, pos
);
230 for (pos
= 0; pos
< active_nr
; pos
++) {
231 struct cache_entry
*ce
= active_cache
[pos
];
232 if (source_tree
&& !(ce
->ce_flags
& CE_UPDATE
))
234 match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, ps_matched
);
237 if (report_path_error(ps_matched
, pathspec
, prefix
))
240 /* "checkout -m path" to recreate conflicted state */
242 unmerge_cache(pathspec
);
244 /* Any unmerged paths? */
245 for (pos
= 0; pos
< active_nr
; pos
++) {
246 struct cache_entry
*ce
= active_cache
[pos
];
247 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
251 warning(_("path '%s' is unmerged"), ce
->name
);
253 errs
|= check_stage(stage
, ce
, pos
);
254 } else if (opts
->merge
) {
255 errs
|= check_all_stages(ce
, pos
);
258 error(_("path '%s' is unmerged"), ce
->name
);
260 pos
= skip_same_name(ce
, pos
) - 1;
266 /* Now we are committed to check them out */
267 memset(&state
, 0, sizeof(state
));
269 state
.refresh_cache
= 1;
270 for (pos
= 0; pos
< active_nr
; pos
++) {
271 struct cache_entry
*ce
= active_cache
[pos
];
272 if (source_tree
&& !(ce
->ce_flags
& CE_UPDATE
))
274 if (match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, NULL
)) {
276 errs
|= checkout_entry(ce
, &state
, NULL
);
280 errs
|= checkout_stage(stage
, ce
, pos
, &state
);
282 errs
|= checkout_merged(pos
, &state
);
283 pos
= skip_same_name(ce
, pos
) - 1;
287 if (write_cache(newfd
, active_cache
, active_nr
) ||
288 commit_locked_index(lock_file
))
289 die(_("unable to write new index file"));
291 read_ref_full("HEAD", rev
, 0, &flag
);
292 head
= lookup_commit_reference_gently(rev
, 1);
294 errs
|= post_checkout_hook(head
, head
, 0);
298 static void show_local_changes(struct object
*head
, struct diff_options
*opts
)
301 /* I think we want full paths, even if we're in a subdirectory. */
302 init_revisions(&rev
, NULL
);
303 rev
.diffopt
.flags
= opts
->flags
;
304 rev
.diffopt
.output_format
|= DIFF_FORMAT_NAME_STATUS
;
305 if (diff_setup_done(&rev
.diffopt
) < 0)
306 die(_("diff_setup_done failed"));
307 add_pending_object(&rev
, head
, NULL
);
308 run_diff_index(&rev
, 0);
311 static void describe_detached_head(const char *msg
, struct commit
*commit
)
313 struct strbuf sb
= STRBUF_INIT
;
314 parse_commit(commit
);
315 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, &sb
);
316 fprintf(stderr
, "%s %s... %s\n", msg
,
317 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
321 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
323 struct unpack_trees_options opts
;
324 struct tree_desc tree_desc
;
326 memset(&opts
, 0, sizeof(opts
));
328 opts
.update
= worktree
;
329 opts
.skip_unmerged
= !worktree
;
332 opts
.fn
= oneway_merge
;
333 opts
.verbose_update
= !o
->quiet
;
334 opts
.src_index
= &the_index
;
335 opts
.dst_index
= &the_index
;
337 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
338 switch (unpack_trees(1, &tree_desc
, &opts
)) {
340 o
->writeout_error
= 1;
342 * We return 0 nevertheless, as the index is all right
343 * and more importantly we have made best efforts to
344 * update paths in the work tree, and we cannot revert
355 const char *name
; /* The short name used */
356 const char *path
; /* The full name of a real branch */
357 struct commit
*commit
; /* The named commit */
360 static void setup_branch_path(struct branch_info
*branch
)
362 struct strbuf buf
= STRBUF_INIT
;
364 strbuf_branchname(&buf
, branch
->name
);
365 if (strcmp(buf
.buf
, branch
->name
))
366 branch
->name
= xstrdup(buf
.buf
);
367 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
368 branch
->path
= strbuf_detach(&buf
, NULL
);
371 static int merge_working_tree(struct checkout_opts
*opts
,
372 struct branch_info
*old
, struct branch_info
*new)
375 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
376 int newfd
= hold_locked_index(lock_file
, 1);
378 if (read_cache_preload(NULL
) < 0)
379 return error(_("corrupt index file"));
381 resolve_undo_clear();
383 ret
= reset_tree(new->commit
->tree
, opts
, 1);
387 struct tree_desc trees
[2];
389 struct unpack_trees_options topts
;
391 memset(&topts
, 0, sizeof(topts
));
393 topts
.src_index
= &the_index
;
394 topts
.dst_index
= &the_index
;
396 setup_unpack_trees_porcelain(&topts
, "checkout");
398 refresh_cache(REFRESH_QUIET
);
400 if (unmerged_cache()) {
401 error(_("you need to resolve your current index first"));
405 /* 2-way merge to the new branch */
406 topts
.initial_checkout
= is_cache_unborn();
409 topts
.gently
= opts
->merge
&& old
->commit
;
410 topts
.verbose_update
= !opts
->quiet
;
411 topts
.fn
= twoway_merge
;
412 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
413 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
414 setup_standard_excludes(topts
.dir
);
415 tree
= parse_tree_indirect(old
->commit
?
416 old
->commit
->object
.sha1
:
417 EMPTY_TREE_SHA1_BIN
);
418 init_tree_desc(&trees
[0], tree
->buffer
, tree
->size
);
419 tree
= parse_tree_indirect(new->commit
->object
.sha1
);
420 init_tree_desc(&trees
[1], tree
->buffer
, tree
->size
);
422 ret
= unpack_trees(2, trees
, &topts
);
425 * Unpack couldn't do a trivial merge; either
426 * give up or do a real merge, depending on
427 * whether the merge flag was used.
431 struct merge_options o
;
436 * Without old->commit, the below is the same as
437 * the two-tree unpack we already tried and failed.
442 /* Do more real merge */
445 * We update the index fully, then write the
446 * tree from the index, then merge the new
447 * branch with the current tree, with the old
448 * branch as the base. Then we reset the index
449 * (but not the working tree) to the new
450 * branch, leaving the working tree as the
451 * merged version, but skipping unmerged
452 * entries in the index.
455 add_files_to_cache(NULL
, NULL
, 0);
457 * NEEDSWORK: carrying over local changes
458 * when branches have different end-of-line
459 * normalization (or clean+smudge rules) is
460 * a pain; plumb in an option to set
463 init_merge_options(&o
);
465 work
= write_tree_from_memory(&o
);
467 ret
= reset_tree(new->commit
->tree
, opts
, 1);
470 o
.ancestor
= old
->name
;
471 o
.branch1
= new->name
;
473 merge_trees(&o
, new->commit
->tree
, work
,
474 old
->commit
->tree
, &result
);
475 ret
= reset_tree(new->commit
->tree
, opts
, 0);
481 if (write_cache(newfd
, active_cache
, active_nr
) ||
482 commit_locked_index(lock_file
))
483 die(_("unable to write new index file"));
485 if (!opts
->force
&& !opts
->quiet
)
486 show_local_changes(&new->commit
->object
, &opts
->diff_options
);
491 static void report_tracking(struct branch_info
*new)
493 struct strbuf sb
= STRBUF_INIT
;
494 struct branch
*branch
= branch_get(new->name
);
496 if (!format_tracking_info(branch
, &sb
))
498 fputs(sb
.buf
, stdout
);
502 static void detach_advice(const char *old_path
, const char *new_name
)
505 "Note: checking out '%s'.\n\n"
506 "You are in 'detached HEAD' state. You can look around, make experimental\n"
507 "changes and commit them, and you can discard any commits you make in this\n"
508 "state without impacting any branches by performing another checkout.\n\n"
509 "If you want to create a new branch to retain commits you create, you may\n"
510 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
511 " git checkout -b new_branch_name\n\n";
513 fprintf(stderr
, fmt
, new_name
);
516 static void update_refs_for_switch(struct checkout_opts
*opts
,
517 struct branch_info
*old
,
518 struct branch_info
*new)
520 struct strbuf msg
= STRBUF_INIT
;
521 const char *old_desc
;
522 if (opts
->new_branch
) {
523 if (opts
->new_orphan_branch
) {
524 if (opts
->new_branch_log
&& !log_all_ref_updates
) {
526 char log_file
[PATH_MAX
];
527 char *ref_name
= mkpath("refs/heads/%s", opts
->new_orphan_branch
);
529 temp
= log_all_ref_updates
;
530 log_all_ref_updates
= 1;
531 if (log_ref_setup(ref_name
, log_file
, sizeof(log_file
))) {
532 fprintf(stderr
, _("Can not do reflog for '%s'\n"),
533 opts
->new_orphan_branch
);
534 log_all_ref_updates
= temp
;
537 log_all_ref_updates
= temp
;
541 create_branch(old
->name
, opts
->new_branch
, new->name
,
542 opts
->new_branch_force
? 1 : 0,
543 opts
->new_branch_log
,
544 opts
->new_branch_force
? 1 : 0,
546 new->name
= opts
->new_branch
;
547 setup_branch_path(new);
550 old_desc
= old
->name
;
551 if (!old_desc
&& old
->commit
)
552 old_desc
= sha1_to_hex(old
->commit
->object
.sha1
);
553 strbuf_addf(&msg
, "checkout: moving from %s to %s",
554 old_desc
? old_desc
: "(invalid)", new->name
);
556 if (!strcmp(new->name
, "HEAD") && !new->path
&& !opts
->force_detach
) {
558 } else if (opts
->force_detach
|| !new->path
) { /* No longer on any branch. */
559 update_ref(msg
.buf
, "HEAD", new->commit
->object
.sha1
, NULL
,
560 REF_NODEREF
, DIE_ON_ERR
);
562 if (old
->path
&& advice_detached_head
)
563 detach_advice(old
->path
, new->name
);
564 describe_detached_head(_("HEAD is now at"), new->commit
);
566 } else if (new->path
) { /* Switch branches. */
567 create_symref("HEAD", new->path
, msg
.buf
);
569 if (old
->path
&& !strcmp(new->path
, old
->path
)) {
570 if (opts
->new_branch_force
)
571 fprintf(stderr
, _("Reset branch '%s'\n"),
574 fprintf(stderr
, _("Already on '%s'\n"),
576 } else if (opts
->new_branch
) {
577 if (opts
->branch_exists
)
578 fprintf(stderr
, _("Switched to and reset branch '%s'\n"), new->name
);
580 fprintf(stderr
, _("Switched to a new branch '%s'\n"), new->name
);
582 fprintf(stderr
, _("Switched to branch '%s'\n"),
586 if (old
->path
&& old
->name
) {
587 char log_file
[PATH_MAX
], ref_file
[PATH_MAX
];
589 git_snpath(log_file
, sizeof(log_file
), "logs/%s", old
->path
);
590 git_snpath(ref_file
, sizeof(ref_file
), "%s", old
->path
);
591 if (!file_exists(ref_file
) && file_exists(log_file
))
592 remove_path(log_file
);
595 remove_branch_state();
596 strbuf_release(&msg
);
598 (new->path
|| (!opts
->force_detach
&& !strcmp(new->name
, "HEAD"))))
599 report_tracking(new);
602 static int add_pending_uninteresting_ref(const char *refname
,
603 const unsigned char *sha1
,
604 int flags
, void *cb_data
)
606 add_pending_sha1(cb_data
, refname
, sha1
, flags
| UNINTERESTING
);
610 static void describe_one_orphan(struct strbuf
*sb
, struct commit
*commit
)
612 parse_commit(commit
);
613 strbuf_addstr(sb
, " ");
615 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
));
616 strbuf_addch(sb
, ' ');
617 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, sb
);
618 strbuf_addch(sb
, '\n');
621 #define ORPHAN_CUTOFF 4
622 static void suggest_reattach(struct commit
*commit
, struct rev_info
*revs
)
624 struct commit
*c
, *last
= NULL
;
625 struct strbuf sb
= STRBUF_INIT
;
627 while ((c
= get_revision(revs
)) != NULL
) {
628 if (lost
< ORPHAN_CUTOFF
)
629 describe_one_orphan(&sb
, c
);
633 if (ORPHAN_CUTOFF
< lost
) {
634 int more
= lost
- ORPHAN_CUTOFF
;
636 describe_one_orphan(&sb
, last
);
638 strbuf_addf(&sb
, _(" ... and %d more.\n"), more
);
643 /* The singular version */
644 "Warning: you are leaving %d commit behind, "
646 "any of your branches:\n\n"
648 /* The plural version */
649 "Warning: you are leaving %d commits behind, "
651 "any of your branches:\n\n"
653 /* Give ngettext() the count */
659 if (advice_detached_head
)
662 "If you want to keep them by creating a new branch, "
663 "this may be a good time\nto do so with:\n\n"
664 " git branch new_branch_name %s\n\n"),
665 sha1_to_hex(commit
->object
.sha1
));
669 * We are about to leave commit that was at the tip of a detached
670 * HEAD. If it is not reachable from any ref, this is the last chance
671 * for the user to do so without resorting to reflog.
673 static void orphaned_commit_warning(struct commit
*commit
)
675 struct rev_info revs
;
676 struct object
*object
= &commit
->object
;
677 struct object_array refs
;
679 init_revisions(&revs
, NULL
);
680 setup_revisions(0, NULL
, &revs
, NULL
);
682 object
->flags
&= ~UNINTERESTING
;
683 add_pending_object(&revs
, object
, sha1_to_hex(object
->sha1
));
685 for_each_ref(add_pending_uninteresting_ref
, &revs
);
688 revs
.leak_pending
= 1;
690 if (prepare_revision_walk(&revs
))
691 die(_("internal error in revision walk"));
692 if (!(commit
->object
.flags
& UNINTERESTING
))
693 suggest_reattach(commit
, &revs
);
695 describe_detached_head(_("Previous HEAD position was"), commit
);
697 clear_commit_marks_for_object_array(&refs
, ALL_REV_FLAGS
);
701 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
704 struct branch_info old
;
705 unsigned char rev
[20];
707 memset(&old
, 0, sizeof(old
));
708 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
710 old
.path
= xstrdup(old
.path
);
711 old
.commit
= lookup_commit_reference_gently(rev
, 1);
712 if (!(flag
& REF_ISSYMREF
)) {
713 free((char *)old
.path
);
717 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
718 old
.name
= old
.path
+ strlen("refs/heads/");
722 new->commit
= old
.commit
;
724 die(_("You are on a branch yet to be born"));
725 parse_commit(new->commit
);
728 ret
= merge_working_tree(opts
, &old
, new);
732 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
733 orphaned_commit_warning(old
.commit
);
735 update_refs_for_switch(opts
, &old
, new);
737 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
738 free((char *)old
.path
);
739 return ret
|| opts
->writeout_error
;
742 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
744 if (!strcmp(var
, "diff.ignoresubmodules")) {
745 struct checkout_opts
*opts
= cb
;
746 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
750 if (!prefixcmp(var
, "submodule."))
751 return parse_submodule_config_option(var
, value
);
753 return git_xmerge_config(var
, value
, NULL
);
756 static int interactive_checkout(const char *revision
, const char **pathspec
,
757 struct checkout_opts
*opts
)
759 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
762 struct tracking_name_data
{
768 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
769 int flags
, void *cb_data
)
771 struct tracking_name_data
*cb
= cb_data
;
774 if (prefixcmp(refname
, "refs/remotes/"))
776 slash
= strchr(refname
+ 13, '/');
777 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
783 cb
->remote
= xstrdup(refname
);
787 static const char *unique_tracking_name(const char *name
)
789 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
791 for_each_ref(check_tracking_name
, &cb_data
);
793 return cb_data
.remote
;
794 free(cb_data
.remote
);
798 static int parse_branchname_arg(int argc
, const char **argv
,
799 int dwim_new_local_branch_ok
,
800 struct branch_info
*new,
801 struct tree
**source_tree
,
802 unsigned char rev
[20],
803 const char **new_branch
)
806 unsigned char branch_rev
[20];
811 * case 1: git checkout <ref> -- [<paths>]
813 * <ref> must be a valid tree, everything after the '--' must be
816 * case 2: git checkout -- [<paths>]
818 * everything after the '--' must be paths.
820 * case 3: git checkout <something> [<paths>]
822 * With no paths, if <something> is a commit, that is to
823 * switch to the branch or detach HEAD at it. As a special case,
824 * if <something> is A...B (missing A or B means HEAD but you can
825 * omit at most one side), and if there is a unique merge base
826 * between A and B, A...B names that merge base.
828 * With no paths, if <something> is _not_ a commit, no -t nor -b
829 * was given, and there is a tracking branch whose name is
830 * <something> in one and only one remote, then this is a short-hand
831 * to fork local <something> from that remote-tracking branch.
833 * Otherwise <something> shall not be ambiguous.
834 * - If it's *only* a reference, treat it like case (1).
835 * - If it's only a path, treat it like case (2).
842 if (!strcmp(argv
[0], "--")) /* case (2) */
846 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
848 if (!strcmp(arg
, "-"))
851 if (get_sha1_mb(arg
, rev
)) {
852 if (has_dash_dash
) /* case (1) */
853 die(_("invalid reference: %s"), arg
);
854 if (dwim_new_local_branch_ok
&&
855 !check_filename(NULL
, arg
) &&
857 const char *remote
= unique_tracking_name(arg
);
858 if (!remote
|| get_sha1(remote
, rev
))
862 /* DWIMmed to create local branch */
868 /* we can't end up being in (2) anymore, eat the argument */
874 setup_branch_path(new);
876 if (!check_refname_format(new->path
, 0) &&
877 !read_ref(new->path
, branch_rev
))
878 hashcpy(rev
, branch_rev
);
880 new->path
= NULL
; /* not an existing branch */
882 new->commit
= lookup_commit_reference_gently(rev
, 1);
885 *source_tree
= parse_tree_indirect(rev
);
887 parse_commit(new->commit
);
888 *source_tree
= new->commit
->tree
;
891 if (!*source_tree
) /* case (1): want a tree */
892 die(_("reference is not a tree: %s"), arg
);
893 if (!has_dash_dash
) {/* case (3 -> 1) */
895 * Do not complain the most common case
896 * git checkout branch
897 * even if there happen to be a file called 'branch';
898 * it would be extremely annoying.
901 verify_non_filename(NULL
, arg
);
911 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
913 struct checkout_opts opts
;
914 unsigned char rev
[20];
915 struct branch_info
new;
916 struct tree
*source_tree
= NULL
;
917 char *conflict_style
= NULL
;
919 int dwim_new_local_branch
= 1;
920 struct option options
[] = {
921 OPT__QUIET(&opts
.quiet
, "suppress progress reporting"),
922 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
923 "create and checkout a new branch"),
924 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
925 "create/reset and checkout a branch"),
926 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "create reflog for new branch"),
927 OPT_BOOLEAN(0, "detach", &opts
.force_detach
, "detach the HEAD at named commit"),
928 OPT_SET_INT('t', "track", &opts
.track
, "set upstream info for new branch",
929 BRANCH_TRACK_EXPLICIT
),
930 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
931 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "checkout our version for unmerged files",
933 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "checkout their version for unmerged files",
935 OPT__FORCE(&opts
.force
, "force checkout (throw away local modifications)"),
936 OPT_BOOLEAN('m', "merge", &opts
.merge
, "perform a 3-way merge with the new branch"),
937 OPT_STRING(0, "conflict", &conflict_style
, "style",
938 "conflict style (merge or diff3)"),
939 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
940 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
941 "second guess 'git checkout no-such-branch'",
942 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
946 memset(&opts
, 0, sizeof(opts
));
947 memset(&new, 0, sizeof(new));
950 git_config(git_checkout_config
, &opts
);
952 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
954 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
955 PARSE_OPT_KEEP_DASHDASH
);
957 /* we can assume from now on new_branch = !new_branch_force */
958 if (opts
.new_branch
&& opts
.new_branch_force
)
959 die(_("-B cannot be used with -b"));
961 /* copy -B over to -b, so that we can just check the latter */
962 if (opts
.new_branch_force
)
963 opts
.new_branch
= opts
.new_branch_force
;
965 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
966 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
967 || opts
.force_detach
))
968 die (_("--patch is incompatible with all other options"));
970 if (opts
.force_detach
&& (opts
.new_branch
|| opts
.new_orphan_branch
))
971 die(_("--detach cannot be used with -b/-B/--orphan"));
972 if (opts
.force_detach
&& 0 < opts
.track
)
973 die(_("--detach cannot be used with -t"));
975 /* --track without -b should DWIM */
976 if (0 < opts
.track
&& !opts
.new_branch
) {
977 const char *argv0
= argv
[0];
978 if (!argc
|| !strcmp(argv0
, "--"))
979 die (_("--track needs a branch name"));
980 if (!prefixcmp(argv0
, "refs/"))
982 if (!prefixcmp(argv0
, "remotes/"))
984 argv0
= strchr(argv0
, '/');
985 if (!argv0
|| !argv0
[1])
986 die (_("Missing branch name; try -b"));
987 opts
.new_branch
= argv0
+ 1;
990 if (opts
.new_orphan_branch
) {
992 die(_("--orphan and -b|-B are mutually exclusive"));
994 die(_("--orphan cannot be used with -t"));
995 opts
.new_branch
= opts
.new_orphan_branch
;
998 if (conflict_style
) {
999 opts
.merge
= 1; /* implied */
1000 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
1003 if (opts
.force
&& opts
.merge
)
1004 die(_("git checkout: -f and -m are incompatible"));
1007 * Extract branch name from command line arguments, so
1008 * all that is left is pathspecs.
1012 * 1) git checkout <tree> -- [<paths>]
1013 * 2) git checkout -- [<paths>]
1014 * 3) git checkout <something> [<paths>]
1016 * including "last branch" syntax and DWIM-ery for names of
1017 * remote branches, erroring out for invalid or ambiguous cases.
1022 dwim_new_local_branch
&&
1023 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
1025 int n
= parse_branchname_arg(argc
, argv
, dwim_ok
,
1026 &new, &source_tree
, rev
, &opts
.new_branch
);
1031 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
1032 opts
.track
= git_branch_track
;
1035 const char **pathspec
= get_pathspec(prefix
, argv
);
1038 die(_("invalid path specification"));
1041 return interactive_checkout(new.name
, pathspec
, &opts
);
1043 /* Checkout paths */
1044 if (opts
.new_branch
) {
1046 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]);
1048 die(_("git checkout: updating paths is incompatible with switching branches."));
1052 if (opts
.force_detach
)
1053 die(_("git checkout: --detach does not take a path argument"));
1055 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
1056 die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
1058 return checkout_paths(source_tree
, pathspec
, prefix
, &opts
);
1062 return interactive_checkout(new.name
, NULL
, &opts
);
1064 if (opts
.new_branch
) {
1065 struct strbuf buf
= STRBUF_INIT
;
1067 opts
.branch_exists
= validate_new_branchname(opts
.new_branch
, &buf
,
1068 !!opts
.new_branch_force
,
1069 !!opts
.new_branch_force
);
1071 strbuf_release(&buf
);
1074 if (new.name
&& !new.commit
) {
1075 die(_("Cannot switch branch to a non-commit."));
1077 if (opts
.writeout_stage
)
1078 die(_("--ours/--theirs is incompatible with switching branches."));
1080 return switch_branches(&opts
, &new);