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 struct pretty_print_context ctx
= {0};
310 parse_commit(commit
);
311 pretty_print_commit(CMIT_FMT_ONELINE
, commit
, &sb
, &ctx
);
312 fprintf(stderr
, "%s %s... %s\n", msg
,
313 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
), sb
.buf
);
317 static int reset_tree(struct tree
*tree
, struct checkout_opts
*o
, int worktree
)
319 struct unpack_trees_options opts
;
320 struct tree_desc tree_desc
;
322 memset(&opts
, 0, sizeof(opts
));
324 opts
.update
= worktree
;
325 opts
.skip_unmerged
= !worktree
;
328 opts
.fn
= oneway_merge
;
329 opts
.verbose_update
= !o
->quiet
;
330 opts
.src_index
= &the_index
;
331 opts
.dst_index
= &the_index
;
333 init_tree_desc(&tree_desc
, tree
->buffer
, tree
->size
);
334 switch (unpack_trees(1, &tree_desc
, &opts
)) {
336 o
->writeout_error
= 1;
338 * We return 0 nevertheless, as the index is all right
339 * and more importantly we have made best efforts to
340 * update paths in the work tree, and we cannot revert
351 const char *name
; /* The short name used */
352 const char *path
; /* The full name of a real branch */
353 struct commit
*commit
; /* The named commit */
356 static void setup_branch_path(struct branch_info
*branch
)
358 struct strbuf buf
= STRBUF_INIT
;
360 strbuf_branchname(&buf
, branch
->name
);
361 if (strcmp(buf
.buf
, branch
->name
))
362 branch
->name
= xstrdup(buf
.buf
);
363 strbuf_splice(&buf
, 0, 0, "refs/heads/", 11);
364 branch
->path
= strbuf_detach(&buf
, NULL
);
367 static int merge_working_tree(struct checkout_opts
*opts
,
368 struct branch_info
*old
, struct branch_info
*new)
371 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
372 int newfd
= hold_locked_index(lock_file
, 1);
374 if (read_cache_preload(NULL
) < 0)
375 return error(_("corrupt index file"));
377 resolve_undo_clear();
379 ret
= reset_tree(new->commit
->tree
, opts
, 1);
383 struct tree_desc trees
[2];
385 struct unpack_trees_options topts
;
387 memset(&topts
, 0, sizeof(topts
));
389 topts
.src_index
= &the_index
;
390 topts
.dst_index
= &the_index
;
392 setup_unpack_trees_porcelain(&topts
, "checkout");
394 refresh_cache(REFRESH_QUIET
);
396 if (unmerged_cache()) {
397 error(_("you need to resolve your current index first"));
401 /* 2-way merge to the new branch */
402 topts
.initial_checkout
= is_cache_unborn();
405 topts
.gently
= opts
->merge
&& old
->commit
;
406 topts
.verbose_update
= !opts
->quiet
;
407 topts
.fn
= twoway_merge
;
408 topts
.dir
= xcalloc(1, sizeof(*topts
.dir
));
409 topts
.dir
->flags
|= DIR_SHOW_IGNORED
;
410 topts
.dir
->exclude_per_dir
= ".gitignore";
411 tree
= parse_tree_indirect(old
->commit
?
412 old
->commit
->object
.sha1
:
413 EMPTY_TREE_SHA1_BIN
);
414 init_tree_desc(&trees
[0], tree
->buffer
, tree
->size
);
415 tree
= parse_tree_indirect(new->commit
->object
.sha1
);
416 init_tree_desc(&trees
[1], tree
->buffer
, tree
->size
);
418 ret
= unpack_trees(2, trees
, &topts
);
421 * Unpack couldn't do a trivial merge; either
422 * give up or do a real merge, depending on
423 * whether the merge flag was used.
427 struct merge_options o
;
432 * Without old->commit, the below is the same as
433 * the two-tree unpack we already tried and failed.
438 /* Do more real merge */
441 * We update the index fully, then write the
442 * tree from the index, then merge the new
443 * branch with the current tree, with the old
444 * branch as the base. Then we reset the index
445 * (but not the working tree) to the new
446 * branch, leaving the working tree as the
447 * merged version, but skipping unmerged
448 * entries in the index.
451 add_files_to_cache(NULL
, NULL
, 0);
453 * NEEDSWORK: carrying over local changes
454 * when branches have different end-of-line
455 * normalization (or clean+smudge rules) is
456 * a pain; plumb in an option to set
459 init_merge_options(&o
);
461 work
= write_tree_from_memory(&o
);
463 ret
= reset_tree(new->commit
->tree
, opts
, 1);
466 o
.ancestor
= old
->name
;
467 o
.branch1
= new->name
;
469 merge_trees(&o
, new->commit
->tree
, work
,
470 old
->commit
->tree
, &result
);
471 ret
= reset_tree(new->commit
->tree
, opts
, 0);
477 if (write_cache(newfd
, active_cache
, active_nr
) ||
478 commit_locked_index(lock_file
))
479 die(_("unable to write new index file"));
481 if (!opts
->force
&& !opts
->quiet
)
482 show_local_changes(&new->commit
->object
, &opts
->diff_options
);
487 static void report_tracking(struct branch_info
*new)
489 struct strbuf sb
= STRBUF_INIT
;
490 struct branch
*branch
= branch_get(new->name
);
492 if (!format_tracking_info(branch
, &sb
))
494 fputs(sb
.buf
, stdout
);
498 static void detach_advice(const char *old_path
, const char *new_name
)
501 "Note: checking out '%s'.\n\n"
502 "You are in 'detached HEAD' state. You can look around, make experimental\n"
503 "changes and commit them, and you can discard any commits you make in this\n"
504 "state without impacting any branches by performing another checkout.\n\n"
505 "If you want to create a new branch to retain commits you create, you may\n"
506 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
507 " git checkout -b new_branch_name\n\n";
509 fprintf(stderr
, fmt
, new_name
);
512 static void update_refs_for_switch(struct checkout_opts
*opts
,
513 struct branch_info
*old
,
514 struct branch_info
*new)
516 struct strbuf msg
= STRBUF_INIT
;
517 const char *old_desc
;
518 if (opts
->new_branch
) {
519 if (opts
->new_orphan_branch
) {
520 if (opts
->new_branch_log
&& !log_all_ref_updates
) {
522 char log_file
[PATH_MAX
];
523 char *ref_name
= mkpath("refs/heads/%s", opts
->new_orphan_branch
);
525 temp
= log_all_ref_updates
;
526 log_all_ref_updates
= 1;
527 if (log_ref_setup(ref_name
, log_file
, sizeof(log_file
))) {
528 fprintf(stderr
, _("Can not do reflog for '%s'\n"),
529 opts
->new_orphan_branch
);
530 log_all_ref_updates
= temp
;
533 log_all_ref_updates
= temp
;
537 create_branch(old
->name
, opts
->new_branch
, new->name
,
538 opts
->new_branch_force
? 1 : 0,
539 opts
->new_branch_log
, opts
->track
);
540 new->name
= opts
->new_branch
;
541 setup_branch_path(new);
544 old_desc
= old
->name
;
545 if (!old_desc
&& old
->commit
)
546 old_desc
= sha1_to_hex(old
->commit
->object
.sha1
);
547 strbuf_addf(&msg
, "checkout: moving from %s to %s",
548 old_desc
? old_desc
: "(invalid)", new->name
);
550 if (!strcmp(new->name
, "HEAD") && !new->path
&& !opts
->force_detach
) {
552 } else if (opts
->force_detach
|| !new->path
) { /* No longer on any branch. */
553 update_ref(msg
.buf
, "HEAD", new->commit
->object
.sha1
, NULL
,
554 REF_NODEREF
, DIE_ON_ERR
);
556 if (old
->path
&& advice_detached_head
)
557 detach_advice(old
->path
, new->name
);
558 describe_detached_head(_("HEAD is now at"), new->commit
);
560 } else if (new->path
) { /* Switch branches. */
561 create_symref("HEAD", new->path
, msg
.buf
);
563 if (old
->path
&& !strcmp(new->path
, old
->path
)) {
564 fprintf(stderr
, _("Already on '%s'\n"),
566 } else if (opts
->new_branch
) {
567 if (opts
->branch_exists
)
568 fprintf(stderr
, _("Switched to and reset branch '%s'\n"), new->name
);
570 fprintf(stderr
, _("Switched to a new branch '%s'\n"), new->name
);
572 fprintf(stderr
, _("Switched to branch '%s'\n"),
576 if (old
->path
&& old
->name
) {
577 char log_file
[PATH_MAX
], ref_file
[PATH_MAX
];
579 git_snpath(log_file
, sizeof(log_file
), "logs/%s", old
->path
);
580 git_snpath(ref_file
, sizeof(ref_file
), "%s", old
->path
);
581 if (!file_exists(ref_file
) && file_exists(log_file
))
582 remove_path(log_file
);
585 remove_branch_state();
586 strbuf_release(&msg
);
588 (new->path
|| (!opts
->force_detach
&& !strcmp(new->name
, "HEAD"))))
589 report_tracking(new);
592 struct rev_list_args
{
598 static void add_one_rev_list_arg(struct rev_list_args
*args
, const char *s
)
600 ALLOC_GROW(args
->argv
, args
->argc
+ 1, args
->alloc
);
601 args
->argv
[args
->argc
++] = s
;
604 static int add_one_ref_to_rev_list_arg(const char *refname
,
605 const unsigned char *sha1
,
609 add_one_rev_list_arg(cb_data
, refname
);
613 static int clear_commit_marks_from_one_ref(const char *refname
,
614 const unsigned char *sha1
,
618 struct commit
*commit
= lookup_commit_reference_gently(sha1
, 1);
620 clear_commit_marks(commit
, -1);
624 static void describe_one_orphan(struct strbuf
*sb
, struct commit
*commit
)
626 struct pretty_print_context ctx
= { 0 };
628 parse_commit(commit
);
629 strbuf_addstr(sb
, " ");
631 find_unique_abbrev(commit
->object
.sha1
, DEFAULT_ABBREV
));
632 strbuf_addch(sb
, ' ');
633 pretty_print_commit(CMIT_FMT_ONELINE
, commit
, sb
, &ctx
);
634 strbuf_addch(sb
, '\n');
637 #define ORPHAN_CUTOFF 4
638 static void suggest_reattach(struct commit
*commit
, struct rev_info
*revs
)
640 struct commit
*c
, *last
= NULL
;
641 struct strbuf sb
= STRBUF_INIT
;
643 while ((c
= get_revision(revs
)) != NULL
) {
644 if (lost
< ORPHAN_CUTOFF
)
645 describe_one_orphan(&sb
, c
);
649 if (ORPHAN_CUTOFF
< lost
) {
650 int more
= lost
- ORPHAN_CUTOFF
;
652 describe_one_orphan(&sb
, last
);
654 strbuf_addf(&sb
, " ... and %d more.\n", more
);
658 "Warning: you are leaving %d commit%s behind, "
660 "any of your branches:\n\n"
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 lost
, ((1 < lost
) ? "s" : ""),
667 sha1_to_hex(commit
->object
.sha1
));
672 * We are about to leave commit that was at the tip of a detached
673 * HEAD. If it is not reachable from any ref, this is the last chance
674 * for the user to do so without resorting to reflog.
676 static void orphaned_commit_warning(struct commit
*commit
)
678 struct rev_list_args args
= { 0, 0, NULL
};
679 struct rev_info revs
;
681 add_one_rev_list_arg(&args
, "(internal)");
682 add_one_rev_list_arg(&args
, sha1_to_hex(commit
->object
.sha1
));
683 add_one_rev_list_arg(&args
, "--not");
684 for_each_ref(add_one_ref_to_rev_list_arg
, &args
);
685 add_one_rev_list_arg(&args
, "--");
686 add_one_rev_list_arg(&args
, NULL
);
688 init_revisions(&revs
, NULL
);
689 if (setup_revisions(args
.argc
- 1, args
.argv
, &revs
, NULL
) != 1)
690 die(_("internal error: only -- alone should have been left"));
691 if (prepare_revision_walk(&revs
))
692 die(_("internal error in revision walk"));
693 if (!(commit
->object
.flags
& UNINTERESTING
))
694 suggest_reattach(commit
, &revs
);
696 describe_detached_head(_("Previous HEAD position was"), commit
);
698 clear_commit_marks(commit
, -1);
699 for_each_ref(clear_commit_marks_from_one_ref
, NULL
);
702 static int switch_branches(struct checkout_opts
*opts
, struct branch_info
*new)
705 struct branch_info old
;
706 unsigned char rev
[20];
708 memset(&old
, 0, sizeof(old
));
709 old
.path
= resolve_ref("HEAD", rev
, 0, &flag
);
710 old
.commit
= lookup_commit_reference_gently(rev
, 1);
711 if (!(flag
& REF_ISSYMREF
))
714 if (old
.path
&& !prefixcmp(old
.path
, "refs/heads/"))
715 old
.name
= old
.path
+ strlen("refs/heads/");
719 new->commit
= old
.commit
;
721 die(_("You are on a branch yet to be born"));
722 parse_commit(new->commit
);
725 ret
= merge_working_tree(opts
, &old
, new);
729 if (!opts
->quiet
&& !old
.path
&& old
.commit
&& new->commit
!= old
.commit
)
730 orphaned_commit_warning(old
.commit
);
732 update_refs_for_switch(opts
, &old
, new);
734 ret
= post_checkout_hook(old
.commit
, new->commit
, 1);
735 return ret
|| opts
->writeout_error
;
738 static int git_checkout_config(const char *var
, const char *value
, void *cb
)
740 if (!strcmp(var
, "diff.ignoresubmodules")) {
741 struct checkout_opts
*opts
= cb
;
742 handle_ignore_submodules_arg(&opts
->diff_options
, value
);
746 if (!prefixcmp(var
, "submodule."))
747 return parse_submodule_config_option(var
, value
);
749 return git_xmerge_config(var
, value
, NULL
);
752 static int interactive_checkout(const char *revision
, const char **pathspec
,
753 struct checkout_opts
*opts
)
755 return run_add_interactive(revision
, "--patch=checkout", pathspec
);
758 struct tracking_name_data
{
764 static int check_tracking_name(const char *refname
, const unsigned char *sha1
,
765 int flags
, void *cb_data
)
767 struct tracking_name_data
*cb
= cb_data
;
770 if (prefixcmp(refname
, "refs/remotes/"))
772 slash
= strchr(refname
+ 13, '/');
773 if (!slash
|| strcmp(slash
+ 1, cb
->name
))
779 cb
->remote
= xstrdup(refname
);
783 static const char *unique_tracking_name(const char *name
)
785 struct tracking_name_data cb_data
= { NULL
, NULL
, 1 };
787 for_each_ref(check_tracking_name
, &cb_data
);
789 return cb_data
.remote
;
790 free(cb_data
.remote
);
794 static int parse_branchname_arg(int argc
, const char **argv
,
795 int dwim_new_local_branch_ok
,
796 struct branch_info
*new,
797 struct tree
**source_tree
,
798 unsigned char rev
[20],
799 const char **new_branch
)
802 unsigned char branch_rev
[20];
807 * case 1: git checkout <ref> -- [<paths>]
809 * <ref> must be a valid tree, everything after the '--' must be
812 * case 2: git checkout -- [<paths>]
814 * everything after the '--' must be paths.
816 * case 3: git checkout <something> [<paths>]
818 * With no paths, if <something> is a commit, that is to
819 * switch to the branch or detach HEAD at it. As a special case,
820 * if <something> is A...B (missing A or B means HEAD but you can
821 * omit at most one side), and if there is a unique merge base
822 * between A and B, A...B names that merge base.
824 * With no paths, if <something> is _not_ a commit, no -t nor -b
825 * was given, and there is a tracking branch whose name is
826 * <something> in one and only one remote, then this is a short-hand
827 * to fork local <something> from that remote-tracking branch.
829 * Otherwise <something> shall not be ambiguous.
830 * - If it's *only* a reference, treat it like case (1).
831 * - If it's only a path, treat it like case (2).
838 if (!strcmp(argv
[0], "--")) /* case (2) */
842 has_dash_dash
= (argc
> 1) && !strcmp(argv
[1], "--");
844 if (!strcmp(arg
, "-"))
847 if (get_sha1_mb(arg
, rev
)) {
848 if (has_dash_dash
) /* case (1) */
849 die(_("invalid reference: %s"), arg
);
850 if (dwim_new_local_branch_ok
&&
851 !check_filename(NULL
, arg
) &&
853 const char *remote
= unique_tracking_name(arg
);
854 if (!remote
|| get_sha1(remote
, rev
))
858 /* DWIMmed to create local branch */
864 /* we can't end up being in (2) anymore, eat the argument */
870 setup_branch_path(new);
872 if (check_ref_format(new->path
) == CHECK_REF_FORMAT_OK
&&
873 resolve_ref(new->path
, branch_rev
, 1, NULL
))
874 hashcpy(rev
, branch_rev
);
876 new->path
= NULL
; /* not an existing branch */
878 new->commit
= lookup_commit_reference_gently(rev
, 1);
881 *source_tree
= parse_tree_indirect(rev
);
883 parse_commit(new->commit
);
884 *source_tree
= new->commit
->tree
;
887 if (!*source_tree
) /* case (1): want a tree */
888 die(_("reference is not a tree: %s"), arg
);
889 if (!has_dash_dash
) {/* case (3 -> 1) */
891 * Do not complain the most common case
892 * git checkout branch
893 * even if there happen to be a file called 'branch';
894 * it would be extremely annoying.
897 verify_non_filename(NULL
, arg
);
907 int cmd_checkout(int argc
, const char **argv
, const char *prefix
)
909 struct checkout_opts opts
;
910 unsigned char rev
[20];
911 struct branch_info
new;
912 struct tree
*source_tree
= NULL
;
913 char *conflict_style
= NULL
;
915 int dwim_new_local_branch
= 1;
916 struct option options
[] = {
917 OPT__QUIET(&opts
.quiet
, "suppress progress reporting"),
918 OPT_STRING('b', NULL
, &opts
.new_branch
, "branch",
919 "create and checkout a new branch"),
920 OPT_STRING('B', NULL
, &opts
.new_branch_force
, "branch",
921 "create/reset and checkout a branch"),
922 OPT_BOOLEAN('l', NULL
, &opts
.new_branch_log
, "create reflog for new branch"),
923 OPT_BOOLEAN(0, "detach", &opts
.force_detach
, "detach the HEAD at named commit"),
924 OPT_SET_INT('t', "track", &opts
.track
, "set upstream info for new branch",
925 BRANCH_TRACK_EXPLICIT
),
926 OPT_STRING(0, "orphan", &opts
.new_orphan_branch
, "new branch", "new unparented branch"),
927 OPT_SET_INT('2', "ours", &opts
.writeout_stage
, "checkout our version for unmerged files",
929 OPT_SET_INT('3', "theirs", &opts
.writeout_stage
, "checkout their version for unmerged files",
931 OPT__FORCE(&opts
.force
, "force checkout (throw away local modifications)"),
932 OPT_BOOLEAN('m', "merge", &opts
.merge
, "perform a 3-way merge with the new branch"),
933 OPT_STRING(0, "conflict", &conflict_style
, "style",
934 "conflict style (merge or diff3)"),
935 OPT_BOOLEAN('p', "patch", &patch_mode
, "select hunks interactively"),
936 { OPTION_BOOLEAN
, 0, "guess", &dwim_new_local_branch
, NULL
,
937 "second guess 'git checkout no-such-branch'",
938 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
942 memset(&opts
, 0, sizeof(opts
));
943 memset(&new, 0, sizeof(new));
946 git_config(git_checkout_config
, &opts
);
948 opts
.track
= BRANCH_TRACK_UNSPECIFIED
;
950 argc
= parse_options(argc
, argv
, prefix
, options
, checkout_usage
,
951 PARSE_OPT_KEEP_DASHDASH
);
953 /* we can assume from now on new_branch = !new_branch_force */
954 if (opts
.new_branch
&& opts
.new_branch_force
)
955 die(_("-B cannot be used with -b"));
957 /* copy -B over to -b, so that we can just check the latter */
958 if (opts
.new_branch_force
)
959 opts
.new_branch
= opts
.new_branch_force
;
961 if (patch_mode
&& (opts
.track
> 0 || opts
.new_branch
962 || opts
.new_branch_log
|| opts
.merge
|| opts
.force
963 || opts
.force_detach
))
964 die (_("--patch is incompatible with all other options"));
966 if (opts
.force_detach
&& (opts
.new_branch
|| opts
.new_orphan_branch
))
967 die("--detach cannot be used with -b/-B/--orphan");
968 if (opts
.force_detach
&& 0 < opts
.track
)
969 die("--detach cannot be used with -t");
971 /* --track without -b should DWIM */
972 if (0 < opts
.track
&& !opts
.new_branch
) {
973 const char *argv0
= argv
[0];
974 if (!argc
|| !strcmp(argv0
, "--"))
975 die (_("--track needs a branch name"));
976 if (!prefixcmp(argv0
, "refs/"))
978 if (!prefixcmp(argv0
, "remotes/"))
980 argv0
= strchr(argv0
, '/');
981 if (!argv0
|| !argv0
[1])
982 die (_("Missing branch name; try -b"));
983 opts
.new_branch
= argv0
+ 1;
986 if (opts
.new_orphan_branch
) {
988 die(_("--orphan and -b|-B are mutually exclusive"));
990 die(_("--orphan cannot be used with -t"));
991 opts
.new_branch
= opts
.new_orphan_branch
;
994 if (conflict_style
) {
995 opts
.merge
= 1; /* implied */
996 git_xmerge_config("merge.conflictstyle", conflict_style
, NULL
);
999 if (opts
.force
&& opts
.merge
)
1000 die(_("git checkout: -f and -m are incompatible"));
1003 * Extract branch name from command line arguments, so
1004 * all that is left is pathspecs.
1008 * 1) git checkout <tree> -- [<paths>]
1009 * 2) git checkout -- [<paths>]
1010 * 3) git checkout <something> [<paths>]
1012 * including "last branch" syntax and DWIM-ery for names of
1013 * remote branches, erroring out for invalid or ambiguous cases.
1018 dwim_new_local_branch
&&
1019 opts
.track
== BRANCH_TRACK_UNSPECIFIED
&&
1021 int n
= parse_branchname_arg(argc
, argv
, dwim_ok
,
1022 &new, &source_tree
, rev
, &opts
.new_branch
);
1027 if (opts
.track
== BRANCH_TRACK_UNSPECIFIED
)
1028 opts
.track
= git_branch_track
;
1031 const char **pathspec
= get_pathspec(prefix
, argv
);
1034 die(_("invalid path specification"));
1037 return interactive_checkout(new.name
, pathspec
, &opts
);
1039 /* Checkout paths */
1040 if (opts
.new_branch
) {
1042 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]);
1044 die(_("git checkout: updating paths is incompatible with switching branches."));
1048 if (opts
.force_detach
)
1049 die("git checkout: --detach does not take a path argument");
1051 if (1 < !!opts
.writeout_stage
+ !!opts
.force
+ !!opts
.merge
)
1052 die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
1054 return checkout_paths(source_tree
, pathspec
, &opts
);
1058 return interactive_checkout(new.name
, NULL
, &opts
);
1060 if (opts
.new_branch
) {
1061 struct strbuf buf
= STRBUF_INIT
;
1062 if (strbuf_check_branch_ref(&buf
, opts
.new_branch
))
1063 die(_("git checkout: we do not like '%s' as a branch name."),
1065 if (!get_sha1(buf
.buf
, rev
)) {
1066 opts
.branch_exists
= 1;
1067 if (!opts
.new_branch_force
)
1068 die(_("git checkout: branch %s already exists"),
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);