Fix sparse warnings
[git.git] / builtin / checkout.c
blob2bf02f2841a84a2a86de08e53328dbbb87ff3587
1 #include "cache.h"
2 #include "builtin.h"
3 #include "parse-options.h"
4 #include "refs.h"
5 #include "commit.h"
6 #include "tree.h"
7 #include "tree-walk.h"
8 #include "cache-tree.h"
9 #include "unpack-trees.h"
10 #include "dir.h"
11 #include "run-command.h"
12 #include "merge-recursive.h"
13 #include "branch.h"
14 #include "diff.h"
15 #include "revision.h"
16 #include "remote.h"
17 #include "blob.h"
18 #include "xdiff-interface.h"
19 #include "ll-merge.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>...",
26 NULL,
29 struct checkout_opts {
30 int quiet;
31 int merge;
32 int force;
33 int force_detach;
34 int writeout_stage;
35 int writeout_error;
37 /* not set by parse_options */
38 int branch_exists;
40 const char *new_branch;
41 const char *new_branch_force;
42 const char *new_orphan_branch;
43 int new_branch_log;
44 enum branch_track track;
45 struct diff_options diff_options;
48 static int post_checkout_hook(struct commit *old, struct commit *new,
49 int changed)
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
56 a commit exists. */
60 static int update_some(const unsigned char *sha1, const char *base, int baselen,
61 const char *pathname, unsigned mode, int stage, void *context)
63 int len;
64 struct cache_entry *ce;
66 if (S_ISDIR(mode))
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);
77 return 0;
80 static int read_tree_some(struct tree *tree, const char **pathspec)
82 read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
84 /* update the index with the given tree's info
85 * for all args, expanding wildcards, and exit
86 * with any non-zero return code.
88 return 0;
91 static int skip_same_name(struct cache_entry *ce, int pos)
93 while (++pos < active_nr &&
94 !strcmp(active_cache[pos]->name, ce->name))
95 ; /* skip */
96 return pos;
99 static int check_stage(int stage, struct cache_entry *ce, int pos)
101 while (pos < active_nr &&
102 !strcmp(active_cache[pos]->name, ce->name)) {
103 if (ce_stage(active_cache[pos]) == stage)
104 return 0;
105 pos++;
107 return error("path '%s' does not have %s version",
108 ce->name,
109 (stage == 2) ? "our" : "their");
112 static int check_all_stages(struct cache_entry *ce, int pos)
114 if (ce_stage(ce) != 1 ||
115 active_nr <= pos + 2 ||
116 strcmp(active_cache[pos+1]->name, ce->name) ||
117 ce_stage(active_cache[pos+1]) != 2 ||
118 strcmp(active_cache[pos+2]->name, ce->name) ||
119 ce_stage(active_cache[pos+2]) != 3)
120 return error("path '%s' does not have all three versions",
121 ce->name);
122 return 0;
125 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
126 struct checkout *state)
128 while (pos < active_nr &&
129 !strcmp(active_cache[pos]->name, ce->name)) {
130 if (ce_stage(active_cache[pos]) == stage)
131 return checkout_entry(active_cache[pos], state, NULL);
132 pos++;
134 return error("path '%s' does not have %s version",
135 ce->name,
136 (stage == 2) ? "our" : "their");
139 static int checkout_merged(int pos, struct checkout *state)
141 struct cache_entry *ce = active_cache[pos];
142 const char *path = ce->name;
143 mmfile_t ancestor, ours, theirs;
144 int status;
145 unsigned char sha1[20];
146 mmbuffer_t result_buf;
148 if (ce_stage(ce) != 1 ||
149 active_nr <= pos + 2 ||
150 strcmp(active_cache[pos+1]->name, path) ||
151 ce_stage(active_cache[pos+1]) != 2 ||
152 strcmp(active_cache[pos+2]->name, path) ||
153 ce_stage(active_cache[pos+2]) != 3)
154 return error("path '%s' does not have all 3 versions", path);
156 read_mmblob(&ancestor, active_cache[pos]->sha1);
157 read_mmblob(&ours, active_cache[pos+1]->sha1);
158 read_mmblob(&theirs, active_cache[pos+2]->sha1);
161 * NEEDSWORK: re-create conflicts from merges with
162 * merge.renormalize set, too
164 status = ll_merge(&result_buf, path, &ancestor, "base",
165 &ours, "ours", &theirs, "theirs", NULL);
166 free(ancestor.ptr);
167 free(ours.ptr);
168 free(theirs.ptr);
169 if (status < 0 || !result_buf.ptr) {
170 free(result_buf.ptr);
171 return error("path '%s': cannot merge", path);
175 * NEEDSWORK:
176 * There is absolutely no reason to write this as a blob object
177 * and create a phony cache entry just to leak. This hack is
178 * primarily to get to the write_entry() machinery that massages
179 * the contents to work-tree format and writes out which only
180 * allows it for a cache entry. The code in write_entry() needs
181 * to be refactored to allow us to feed a <buffer, size, mode>
182 * instead of a cache entry. Such a refactoring would help
183 * merge_recursive as well (it also writes the merge result to the
184 * object database even when it may contain conflicts).
186 if (write_sha1_file(result_buf.ptr, result_buf.size,
187 blob_type, sha1))
188 die("Unable to add merge result for '%s'", path);
189 ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
190 sha1,
191 path, 2, 0);
192 if (!ce)
193 die("make_cache_entry failed for path '%s'", path);
194 status = checkout_entry(ce, state, NULL);
195 return status;
198 static int checkout_paths(struct tree *source_tree, const char **pathspec,
199 struct checkout_opts *opts)
201 int pos;
202 struct checkout state;
203 static char *ps_matched;
204 unsigned char rev[20];
205 int flag;
206 struct commit *head;
207 int errs = 0;
208 int stage = opts->writeout_stage;
209 int merge = opts->merge;
210 int newfd;
211 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
213 newfd = hold_locked_index(lock_file, 1);
214 if (read_cache_preload(pathspec) < 0)
215 return error("corrupt index file");
217 if (source_tree)
218 read_tree_some(source_tree, pathspec);
220 for (pos = 0; pathspec[pos]; pos++)
222 ps_matched = xcalloc(1, pos);
224 for (pos = 0; pos < active_nr; pos++) {
225 struct cache_entry *ce = active_cache[pos];
226 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
229 if (report_path_error(ps_matched, pathspec, 0))
230 return 1;
232 /* "checkout -m path" to recreate conflicted state */
233 if (opts->merge)
234 unmerge_cache(pathspec);
236 /* Any unmerged paths? */
237 for (pos = 0; pos < active_nr; pos++) {
238 struct cache_entry *ce = active_cache[pos];
239 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
240 if (!ce_stage(ce))
241 continue;
242 if (opts->force) {
243 warning("path '%s' is unmerged", ce->name);
244 } else if (stage) {
245 errs |= check_stage(stage, ce, pos);
246 } else if (opts->merge) {
247 errs |= check_all_stages(ce, pos);
248 } else {
249 errs = 1;
250 error("path '%s' is unmerged", ce->name);
252 pos = skip_same_name(ce, pos) - 1;
255 if (errs)
256 return 1;
258 /* Now we are committed to check them out */
259 memset(&state, 0, sizeof(state));
260 state.force = 1;
261 state.refresh_cache = 1;
262 for (pos = 0; pos < active_nr; pos++) {
263 struct cache_entry *ce = active_cache[pos];
264 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
265 if (!ce_stage(ce)) {
266 errs |= checkout_entry(ce, &state, NULL);
267 continue;
269 if (stage)
270 errs |= checkout_stage(stage, ce, pos, &state);
271 else if (merge)
272 errs |= checkout_merged(pos, &state);
273 pos = skip_same_name(ce, pos) - 1;
277 if (write_cache(newfd, active_cache, active_nr) ||
278 commit_locked_index(lock_file))
279 die("unable to write new index file");
281 resolve_ref("HEAD", rev, 0, &flag);
282 head = lookup_commit_reference_gently(rev, 1);
284 errs |= post_checkout_hook(head, head, 0);
285 return errs;
288 static void show_local_changes(struct object *head, struct diff_options *opts)
290 struct rev_info rev;
291 /* I think we want full paths, even if we're in a subdirectory. */
292 init_revisions(&rev, NULL);
293 rev.diffopt.flags = opts->flags;
294 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
295 if (diff_setup_done(&rev.diffopt) < 0)
296 die("diff_setup_done failed");
297 add_pending_object(&rev, head, NULL);
298 run_diff_index(&rev, 0);
301 static void describe_detached_head(const char *msg, struct commit *commit)
303 struct strbuf sb = STRBUF_INIT;
304 struct pretty_print_context ctx = {0};
305 parse_commit(commit);
306 pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
307 fprintf(stderr, "%s %s... %s\n", msg,
308 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
309 strbuf_release(&sb);
312 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
314 struct unpack_trees_options opts;
315 struct tree_desc tree_desc;
317 memset(&opts, 0, sizeof(opts));
318 opts.head_idx = -1;
319 opts.update = worktree;
320 opts.skip_unmerged = !worktree;
321 opts.reset = 1;
322 opts.merge = 1;
323 opts.fn = oneway_merge;
324 opts.verbose_update = !o->quiet;
325 opts.src_index = &the_index;
326 opts.dst_index = &the_index;
327 parse_tree(tree);
328 init_tree_desc(&tree_desc, tree->buffer, tree->size);
329 switch (unpack_trees(1, &tree_desc, &opts)) {
330 case -2:
331 o->writeout_error = 1;
333 * We return 0 nevertheless, as the index is all right
334 * and more importantly we have made best efforts to
335 * update paths in the work tree, and we cannot revert
336 * them.
338 case 0:
339 return 0;
340 default:
341 return 128;
345 struct branch_info {
346 const char *name; /* The short name used */
347 const char *path; /* The full name of a real branch */
348 struct commit *commit; /* The named commit */
351 static void setup_branch_path(struct branch_info *branch)
353 struct strbuf buf = STRBUF_INIT;
355 strbuf_branchname(&buf, branch->name);
356 if (strcmp(buf.buf, branch->name))
357 branch->name = xstrdup(buf.buf);
358 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
359 branch->path = strbuf_detach(&buf, NULL);
362 static int merge_working_tree(struct checkout_opts *opts,
363 struct branch_info *old, struct branch_info *new)
365 int ret;
366 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
367 int newfd = hold_locked_index(lock_file, 1);
369 if (read_cache_preload(NULL) < 0)
370 return error("corrupt index file");
372 resolve_undo_clear();
373 if (opts->force) {
374 ret = reset_tree(new->commit->tree, opts, 1);
375 if (ret)
376 return ret;
377 } else {
378 struct tree_desc trees[2];
379 struct tree *tree;
380 struct unpack_trees_options topts;
382 memset(&topts, 0, sizeof(topts));
383 topts.head_idx = -1;
384 topts.src_index = &the_index;
385 topts.dst_index = &the_index;
387 setup_unpack_trees_porcelain(&topts, "checkout");
389 refresh_cache(REFRESH_QUIET);
391 if (unmerged_cache()) {
392 error("you need to resolve your current index first");
393 return 1;
396 /* 2-way merge to the new branch */
397 topts.initial_checkout = is_cache_unborn();
398 topts.update = 1;
399 topts.merge = 1;
400 topts.gently = opts->merge && old->commit;
401 topts.verbose_update = !opts->quiet;
402 topts.fn = twoway_merge;
403 topts.dir = xcalloc(1, sizeof(*topts.dir));
404 topts.dir->flags |= DIR_SHOW_IGNORED;
405 topts.dir->exclude_per_dir = ".gitignore";
406 tree = parse_tree_indirect(old->commit ?
407 old->commit->object.sha1 :
408 EMPTY_TREE_SHA1_BIN);
409 init_tree_desc(&trees[0], tree->buffer, tree->size);
410 tree = parse_tree_indirect(new->commit->object.sha1);
411 init_tree_desc(&trees[1], tree->buffer, tree->size);
413 ret = unpack_trees(2, trees, &topts);
414 if (ret == -1) {
416 * Unpack couldn't do a trivial merge; either
417 * give up or do a real merge, depending on
418 * whether the merge flag was used.
420 struct tree *result;
421 struct tree *work;
422 struct merge_options o;
423 if (!opts->merge)
424 return 1;
427 * Without old->commit, the below is the same as
428 * the two-tree unpack we already tried and failed.
430 if (!old->commit)
431 return 1;
433 /* Do more real merge */
436 * We update the index fully, then write the
437 * tree from the index, then merge the new
438 * branch with the current tree, with the old
439 * branch as the base. Then we reset the index
440 * (but not the working tree) to the new
441 * branch, leaving the working tree as the
442 * merged version, but skipping unmerged
443 * entries in the index.
446 add_files_to_cache(NULL, NULL, 0);
448 * NEEDSWORK: carrying over local changes
449 * when branches have different end-of-line
450 * normalization (or clean+smudge rules) is
451 * a pain; plumb in an option to set
452 * o.renormalize?
454 init_merge_options(&o);
455 o.verbosity = 0;
456 work = write_tree_from_memory(&o);
458 ret = reset_tree(new->commit->tree, opts, 1);
459 if (ret)
460 return ret;
461 o.ancestor = old->name;
462 o.branch1 = new->name;
463 o.branch2 = "local";
464 merge_trees(&o, new->commit->tree, work,
465 old->commit->tree, &result);
466 ret = reset_tree(new->commit->tree, opts, 0);
467 if (ret)
468 return ret;
472 if (write_cache(newfd, active_cache, active_nr) ||
473 commit_locked_index(lock_file))
474 die("unable to write new index file");
476 if (!opts->force && !opts->quiet)
477 show_local_changes(&new->commit->object, &opts->diff_options);
479 return 0;
482 static void report_tracking(struct branch_info *new)
484 struct strbuf sb = STRBUF_INIT;
485 struct branch *branch = branch_get(new->name);
487 if (!format_tracking_info(branch, &sb))
488 return;
489 fputs(sb.buf, stdout);
490 strbuf_release(&sb);
493 static void detach_advice(const char *old_path, const char *new_name)
495 const char fmt[] =
496 "Note: checking out '%s'.\n\n"
497 "You are in 'detached HEAD' state. You can look around, make experimental\n"
498 "changes and commit them, and you can discard any commits you make in this\n"
499 "state without impacting any branches by performing another checkout.\n\n"
500 "If you want to create a new branch to retain commits you create, you may\n"
501 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
502 " git checkout -b new_branch_name\n\n";
504 fprintf(stderr, fmt, new_name);
507 static void update_refs_for_switch(struct checkout_opts *opts,
508 struct branch_info *old,
509 struct branch_info *new)
511 struct strbuf msg = STRBUF_INIT;
512 const char *old_desc;
513 if (opts->new_branch) {
514 if (opts->new_orphan_branch) {
515 if (opts->new_branch_log && !log_all_ref_updates) {
516 int temp;
517 char log_file[PATH_MAX];
518 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
520 temp = log_all_ref_updates;
521 log_all_ref_updates = 1;
522 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
523 fprintf(stderr, "Can not do reflog for '%s'\n",
524 opts->new_orphan_branch);
525 log_all_ref_updates = temp;
526 return;
528 log_all_ref_updates = temp;
531 else
532 create_branch(old->name, opts->new_branch, new->name,
533 opts->new_branch_force ? 1 : 0,
534 opts->new_branch_log, opts->track);
535 new->name = opts->new_branch;
536 setup_branch_path(new);
539 old_desc = old->name;
540 if (!old_desc && old->commit)
541 old_desc = sha1_to_hex(old->commit->object.sha1);
542 strbuf_addf(&msg, "checkout: moving from %s to %s",
543 old_desc ? old_desc : "(invalid)", new->name);
545 if (!strcmp(new->name, "HEAD") && !new->path && !opts->force_detach) {
546 /* Nothing to do. */
547 } else if (opts->force_detach || !new->path) { /* No longer on any branch. */
548 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
549 REF_NODEREF, DIE_ON_ERR);
550 if (!opts->quiet) {
551 if (old->path && advice_detached_head)
552 detach_advice(old->path, new->name);
553 describe_detached_head("HEAD is now at", new->commit);
555 } else if (new->path) { /* Switch branches. */
556 create_symref("HEAD", new->path, msg.buf);
557 if (!opts->quiet) {
558 if (old->path && !strcmp(new->path, old->path))
559 fprintf(stderr, "Already on '%s'\n",
560 new->name);
561 else if (opts->new_branch)
562 fprintf(stderr, "Switched to%s branch '%s'\n",
563 opts->branch_exists ? " and reset" : " a new",
564 new->name);
565 else
566 fprintf(stderr, "Switched to branch '%s'\n",
567 new->name);
569 if (old->path && old->name) {
570 char log_file[PATH_MAX], ref_file[PATH_MAX];
572 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
573 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
574 if (!file_exists(ref_file) && file_exists(log_file))
575 remove_path(log_file);
578 remove_branch_state();
579 strbuf_release(&msg);
580 if (!opts->quiet &&
581 (new->path || (!opts->force_detach && !strcmp(new->name, "HEAD"))))
582 report_tracking(new);
585 struct rev_list_args {
586 int argc;
587 int alloc;
588 const char **argv;
591 static void add_one_rev_list_arg(struct rev_list_args *args, const char *s)
593 ALLOC_GROW(args->argv, args->argc + 1, args->alloc);
594 args->argv[args->argc++] = s;
597 static int add_one_ref_to_rev_list_arg(const char *refname,
598 const unsigned char *sha1,
599 int flags,
600 void *cb_data)
602 add_one_rev_list_arg(cb_data, refname);
603 return 0;
607 static void describe_one_orphan(struct strbuf *sb, struct commit *commit)
609 struct pretty_print_context ctx = { 0 };
611 parse_commit(commit);
612 strbuf_addstr(sb, " - ");
613 pretty_print_commit(CMIT_FMT_ONELINE, commit, sb, &ctx);
614 strbuf_addch(sb, '\n');
617 #define ORPHAN_CUTOFF 4
618 static void suggest_reattach(struct commit *commit, struct rev_info *revs)
620 struct commit *c, *last = NULL;
621 struct strbuf sb = STRBUF_INIT;
622 int lost = 0;
623 while ((c = get_revision(revs)) != NULL) {
624 if (lost < ORPHAN_CUTOFF)
625 describe_one_orphan(&sb, c);
626 last = c;
627 lost++;
629 if (ORPHAN_CUTOFF < lost) {
630 int more = lost - ORPHAN_CUTOFF;
631 if (more == 1)
632 describe_one_orphan(&sb, last);
633 else
634 strbuf_addf(&sb, " ... and %d more.\n", more);
637 fprintf(stderr,
638 "Warning: you are leaving %d commit%s behind, "
639 "not connected to\n"
640 "any of your branches:\n\n"
641 "%s\n"
642 "If you want to keep them by creating a new branch, "
643 "this may be a good time\nto do so with:\n\n"
644 " git branch new_branch_name %s\n\n",
645 lost, ((1 < lost) ? "s" : ""),
646 sb.buf,
647 sha1_to_hex(commit->object.sha1));
648 strbuf_release(&sb);
652 * We are about to leave commit that was at the tip of a detached
653 * HEAD. If it is not reachable from any ref, this is the last chance
654 * for the user to do so without resorting to reflog.
656 static void orphaned_commit_warning(struct commit *commit)
658 struct rev_list_args args = { 0, 0, NULL };
659 struct rev_info revs;
661 add_one_rev_list_arg(&args, "(internal)");
662 add_one_rev_list_arg(&args, sha1_to_hex(commit->object.sha1));
663 add_one_rev_list_arg(&args, "--not");
664 for_each_ref(add_one_ref_to_rev_list_arg, &args);
665 add_one_rev_list_arg(&args, "--");
666 add_one_rev_list_arg(&args, NULL);
668 init_revisions(&revs, NULL);
669 if (setup_revisions(args.argc - 1, args.argv, &revs, NULL) != 1)
670 die("internal error: only -- alone should have been left");
671 if (prepare_revision_walk(&revs))
672 die("internal error in revision walk");
673 if (!(commit->object.flags & UNINTERESTING))
674 suggest_reattach(commit, &revs);
675 else
676 describe_detached_head("Previous HEAD position was", commit);
679 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
681 int ret = 0;
682 struct branch_info old;
683 unsigned char rev[20];
684 int flag;
685 memset(&old, 0, sizeof(old));
686 old.path = resolve_ref("HEAD", rev, 0, &flag);
687 old.commit = lookup_commit_reference_gently(rev, 1);
688 if (!(flag & REF_ISSYMREF))
689 old.path = NULL;
691 if (old.path && !prefixcmp(old.path, "refs/heads/"))
692 old.name = old.path + strlen("refs/heads/");
694 if (!new->name) {
695 new->name = "HEAD";
696 new->commit = old.commit;
697 if (!new->commit)
698 die("You are on a branch yet to be born");
699 parse_commit(new->commit);
702 ret = merge_working_tree(opts, &old, new);
703 if (ret)
704 return ret;
706 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
707 orphaned_commit_warning(old.commit);
709 update_refs_for_switch(opts, &old, new);
711 ret = post_checkout_hook(old.commit, new->commit, 1);
712 return ret || opts->writeout_error;
715 static int git_checkout_config(const char *var, const char *value, void *cb)
717 if (!strcmp(var, "diff.ignoresubmodules")) {
718 struct checkout_opts *opts = cb;
719 handle_ignore_submodules_arg(&opts->diff_options, value);
720 return 0;
723 if (!prefixcmp(var, "submodule."))
724 return parse_submodule_config_option(var, value);
726 return git_xmerge_config(var, value, NULL);
729 static int interactive_checkout(const char *revision, const char **pathspec,
730 struct checkout_opts *opts)
732 return run_add_interactive(revision, "--patch=checkout", pathspec);
735 struct tracking_name_data {
736 const char *name;
737 char *remote;
738 int unique;
741 static int check_tracking_name(const char *refname, const unsigned char *sha1,
742 int flags, void *cb_data)
744 struct tracking_name_data *cb = cb_data;
745 const char *slash;
747 if (prefixcmp(refname, "refs/remotes/"))
748 return 0;
749 slash = strchr(refname + 13, '/');
750 if (!slash || strcmp(slash + 1, cb->name))
751 return 0;
752 if (cb->remote) {
753 cb->unique = 0;
754 return 0;
756 cb->remote = xstrdup(refname);
757 return 0;
760 static const char *unique_tracking_name(const char *name)
762 struct tracking_name_data cb_data = { NULL, NULL, 1 };
763 cb_data.name = name;
764 for_each_ref(check_tracking_name, &cb_data);
765 if (cb_data.unique)
766 return cb_data.remote;
767 free(cb_data.remote);
768 return NULL;
771 static int parse_branchname_arg(int argc, const char **argv,
772 int dwim_new_local_branch_ok,
773 struct branch_info *new,
774 struct tree **source_tree,
775 unsigned char rev[20],
776 const char **new_branch)
778 int argcount = 0;
779 unsigned char branch_rev[20];
780 const char *arg;
781 int has_dash_dash;
784 * case 1: git checkout <ref> -- [<paths>]
786 * <ref> must be a valid tree, everything after the '--' must be
787 * a path.
789 * case 2: git checkout -- [<paths>]
791 * everything after the '--' must be paths.
793 * case 3: git checkout <something> [<paths>]
795 * With no paths, if <something> is a commit, that is to
796 * switch to the branch or detach HEAD at it. As a special case,
797 * if <something> is A...B (missing A or B means HEAD but you can
798 * omit at most one side), and if there is a unique merge base
799 * between A and B, A...B names that merge base.
801 * With no paths, if <something> is _not_ a commit, no -t nor -b
802 * was given, and there is a tracking branch whose name is
803 * <something> in one and only one remote, then this is a short-hand
804 * to fork local <something> from that remote-tracking branch.
806 * Otherwise <something> shall not be ambiguous.
807 * - If it's *only* a reference, treat it like case (1).
808 * - If it's only a path, treat it like case (2).
809 * - else: fail.
812 if (!argc)
813 return 0;
815 if (!strcmp(argv[0], "--")) /* case (2) */
816 return 1;
818 arg = argv[0];
819 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
821 if (!strcmp(arg, "-"))
822 arg = "@{-1}";
824 if (get_sha1_mb(arg, rev)) {
825 if (has_dash_dash) /* case (1) */
826 die("invalid reference: %s", arg);
827 if (dwim_new_local_branch_ok &&
828 !check_filename(NULL, arg) &&
829 argc == 1) {
830 const char *remote = unique_tracking_name(arg);
831 if (!remote || get_sha1(remote, rev))
832 return argcount;
833 *new_branch = arg;
834 arg = remote;
835 /* DWIMmed to create local branch */
836 } else {
837 return argcount;
841 /* we can't end up being in (2) anymore, eat the argument */
842 argcount++;
843 argv++;
844 argc--;
846 new->name = arg;
847 setup_branch_path(new);
849 if (check_ref_format(new->path) == CHECK_REF_FORMAT_OK &&
850 resolve_ref(new->path, branch_rev, 1, NULL))
851 hashcpy(rev, branch_rev);
852 else
853 new->path = NULL; /* not an existing branch */
855 new->commit = lookup_commit_reference_gently(rev, 1);
856 if (!new->commit) {
857 /* not a commit */
858 *source_tree = parse_tree_indirect(rev);
859 } else {
860 parse_commit(new->commit);
861 *source_tree = new->commit->tree;
864 if (!*source_tree) /* case (1): want a tree */
865 die("reference is not a tree: %s", arg);
866 if (!has_dash_dash) {/* case (3 -> 1) */
868 * Do not complain the most common case
869 * git checkout branch
870 * even if there happen to be a file called 'branch';
871 * it would be extremely annoying.
873 if (argc)
874 verify_non_filename(NULL, arg);
875 } else {
876 argcount++;
877 argv++;
878 argc--;
881 return argcount;
884 int cmd_checkout(int argc, const char **argv, const char *prefix)
886 struct checkout_opts opts;
887 unsigned char rev[20];
888 struct branch_info new;
889 struct tree *source_tree = NULL;
890 char *conflict_style = NULL;
891 int patch_mode = 0;
892 int dwim_new_local_branch = 1;
893 struct option options[] = {
894 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
895 OPT_STRING('b', NULL, &opts.new_branch, "branch",
896 "create and checkout a new branch"),
897 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
898 "create/reset and checkout a branch"),
899 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
900 OPT_BOOLEAN(0, "detach", &opts.force_detach, "detach the HEAD at named commit"),
901 OPT_SET_INT('t', "track", &opts.track, "set upstream info for new branch",
902 BRANCH_TRACK_EXPLICIT),
903 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
904 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
906 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
908 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
909 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
910 OPT_STRING(0, "conflict", &conflict_style, "style",
911 "conflict style (merge or diff3)"),
912 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
913 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
914 "second guess 'git checkout no-such-branch'",
915 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
916 OPT_END(),
919 memset(&opts, 0, sizeof(opts));
920 memset(&new, 0, sizeof(new));
922 gitmodules_config();
923 git_config(git_checkout_config, &opts);
925 opts.track = BRANCH_TRACK_UNSPECIFIED;
927 argc = parse_options(argc, argv, prefix, options, checkout_usage,
928 PARSE_OPT_KEEP_DASHDASH);
930 /* we can assume from now on new_branch = !new_branch_force */
931 if (opts.new_branch && opts.new_branch_force)
932 die("-B cannot be used with -b");
934 /* copy -B over to -b, so that we can just check the latter */
935 if (opts.new_branch_force)
936 opts.new_branch = opts.new_branch_force;
938 if (patch_mode && (opts.track > 0 || opts.new_branch
939 || opts.new_branch_log || opts.merge || opts.force
940 || opts.force_detach))
941 die ("--patch is incompatible with all other options");
943 if (opts.force_detach && (opts.new_branch || opts.new_orphan_branch))
944 die("--detach cannot be used with -b/-B/--orphan");
945 if (opts.force_detach && 0 < opts.track)
946 die("--detach cannot be used with -t");
948 /* --track without -b should DWIM */
949 if (0 < opts.track && !opts.new_branch) {
950 const char *argv0 = argv[0];
951 if (!argc || !strcmp(argv0, "--"))
952 die ("--track needs a branch name");
953 if (!prefixcmp(argv0, "refs/"))
954 argv0 += 5;
955 if (!prefixcmp(argv0, "remotes/"))
956 argv0 += 8;
957 argv0 = strchr(argv0, '/');
958 if (!argv0 || !argv0[1])
959 die ("Missing branch name; try -b");
960 opts.new_branch = argv0 + 1;
963 if (opts.new_orphan_branch) {
964 if (opts.new_branch)
965 die("--orphan and -b|-B are mutually exclusive");
966 if (opts.track > 0)
967 die("--orphan cannot be used with -t");
968 opts.new_branch = opts.new_orphan_branch;
971 if (conflict_style) {
972 opts.merge = 1; /* implied */
973 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
976 if (opts.force && opts.merge)
977 die("git checkout: -f and -m are incompatible");
980 * Extract branch name from command line arguments, so
981 * all that is left is pathspecs.
983 * Handle
985 * 1) git checkout <tree> -- [<paths>]
986 * 2) git checkout -- [<paths>]
987 * 3) git checkout <something> [<paths>]
989 * including "last branch" syntax and DWIM-ery for names of
990 * remote branches, erroring out for invalid or ambiguous cases.
992 if (argc) {
993 int dwim_ok =
994 !patch_mode &&
995 dwim_new_local_branch &&
996 opts.track == BRANCH_TRACK_UNSPECIFIED &&
997 !opts.new_branch;
998 int n = parse_branchname_arg(argc, argv, dwim_ok,
999 &new, &source_tree, rev, &opts.new_branch);
1000 argv += n;
1001 argc -= n;
1004 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
1005 opts.track = git_branch_track;
1007 if (argc) {
1008 const char **pathspec = get_pathspec(prefix, argv);
1010 if (!pathspec)
1011 die("invalid path specification");
1013 if (patch_mode)
1014 return interactive_checkout(new.name, pathspec, &opts);
1016 /* Checkout paths */
1017 if (opts.new_branch) {
1018 if (argc == 1) {
1019 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]);
1020 } else {
1021 die("git checkout: updating paths is incompatible with switching branches.");
1025 if (opts.force_detach)
1026 die("git checkout: --detach does not take a path argument");
1028 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
1029 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
1031 return checkout_paths(source_tree, pathspec, &opts);
1034 if (patch_mode)
1035 return interactive_checkout(new.name, NULL, &opts);
1037 if (opts.new_branch) {
1038 struct strbuf buf = STRBUF_INIT;
1039 if (strbuf_check_branch_ref(&buf, opts.new_branch))
1040 die("git checkout: we do not like '%s' as a branch name.",
1041 opts.new_branch);
1042 if (!get_sha1(buf.buf, rev)) {
1043 opts.branch_exists = 1;
1044 if (!opts.new_branch_force)
1045 die("git checkout: branch %s already exists",
1046 opts.new_branch);
1048 strbuf_release(&buf);
1051 if (new.name && !new.commit) {
1052 die("Cannot switch branch to a non-commit.");
1054 if (opts.writeout_stage)
1055 die("--ours/--theirs is incompatible with switching branches.");
1057 return switch_branches(&opts, &new);