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,
27 };
29 struct checkout_opts {
30 int quiet;
31 int merge;
32 int force;
33 int writeout_stage;
34 int writeout_error;
36 /* not set by parse_options */
37 int branch_exists;
39 const char *new_branch;
40 const char *new_branch_force;
41 const char *new_orphan_branch;
42 int new_branch_log;
43 enum branch_track track;
44 struct diff_options diff_options;
45 };
47 static int post_checkout_hook(struct commit *old, struct commit *new,
48 int changed)
49 {
50 return run_hook(NULL, "post-checkout",
51 sha1_to_hex(old ? old->object.sha1 : null_sha1),
52 sha1_to_hex(new ? new->object.sha1 : null_sha1),
53 changed ? "1" : "0", NULL);
54 /* "new" can be NULL when checking out from the index before
55 a commit exists. */
57 }
59 static int update_some(const unsigned char *sha1, const char *base, int baselen,
60 const char *pathname, unsigned mode, int stage, void *context)
61 {
62 int len;
63 struct cache_entry *ce;
65 if (S_ISDIR(mode))
66 return READ_TREE_RECURSIVE;
68 len = baselen + strlen(pathname);
69 ce = xcalloc(1, cache_entry_size(len));
70 hashcpy(ce->sha1, sha1);
71 memcpy(ce->name, base, baselen);
72 memcpy(ce->name + baselen, pathname, len - baselen);
73 ce->ce_flags = create_ce_flags(len, 0);
74 ce->ce_mode = create_ce_mode(mode);
75 add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
76 return 0;
77 }
79 static int read_tree_some(struct tree *tree, const char **pathspec)
80 {
81 read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
83 /* update the index with the given tree's info
84 * for all args, expanding wildcards, and exit
85 * with any non-zero return code.
86 */
87 return 0;
88 }
90 static int skip_same_name(struct cache_entry *ce, int pos)
91 {
92 while (++pos < active_nr &&
93 !strcmp(active_cache[pos]->name, ce->name))
94 ; /* skip */
95 return pos;
96 }
98 static int check_stage(int stage, struct cache_entry *ce, int pos)
99 {
100 while (pos < active_nr &&
101 !strcmp(active_cache[pos]->name, ce->name)) {
102 if (ce_stage(active_cache[pos]) == stage)
103 return 0;
104 pos++;
105 }
106 return error("path '%s' does not have %s version",
107 ce->name,
108 (stage == 2) ? "our" : "their");
109 }
111 static int check_all_stages(struct cache_entry *ce, int pos)
112 {
113 if (ce_stage(ce) != 1 ||
114 active_nr <= pos + 2 ||
115 strcmp(active_cache[pos+1]->name, ce->name) ||
116 ce_stage(active_cache[pos+1]) != 2 ||
117 strcmp(active_cache[pos+2]->name, ce->name) ||
118 ce_stage(active_cache[pos+2]) != 3)
119 return error("path '%s' does not have all three versions",
120 ce->name);
121 return 0;
122 }
124 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
125 struct checkout *state)
126 {
127 while (pos < active_nr &&
128 !strcmp(active_cache[pos]->name, ce->name)) {
129 if (ce_stage(active_cache[pos]) == stage)
130 return checkout_entry(active_cache[pos], state, NULL);
131 pos++;
132 }
133 return error("path '%s' does not have %s version",
134 ce->name,
135 (stage == 2) ? "our" : "their");
136 }
138 static int checkout_merged(int pos, struct checkout *state)
139 {
140 struct cache_entry *ce = active_cache[pos];
141 const char *path = ce->name;
142 mmfile_t ancestor, ours, theirs;
143 int status;
144 unsigned char sha1[20];
145 mmbuffer_t result_buf;
147 if (ce_stage(ce) != 1 ||
148 active_nr <= pos + 2 ||
149 strcmp(active_cache[pos+1]->name, path) ||
150 ce_stage(active_cache[pos+1]) != 2 ||
151 strcmp(active_cache[pos+2]->name, path) ||
152 ce_stage(active_cache[pos+2]) != 3)
153 return error("path '%s' does not have all 3 versions", path);
155 read_mmblob(&ancestor, active_cache[pos]->sha1);
156 read_mmblob(&ours, active_cache[pos+1]->sha1);
157 read_mmblob(&theirs, active_cache[pos+2]->sha1);
159 /*
160 * NEEDSWORK: re-create conflicts from merges with
161 * merge.renormalize set, too
162 */
163 status = ll_merge(&result_buf, path, &ancestor, "base",
164 &ours, "ours", &theirs, "theirs", NULL);
165 free(ancestor.ptr);
166 free(ours.ptr);
167 free(theirs.ptr);
168 if (status < 0 || !result_buf.ptr) {
169 free(result_buf.ptr);
170 return error("path '%s': cannot merge", path);
171 }
173 /*
174 * NEEDSWORK:
175 * There is absolutely no reason to write this as a blob object
176 * and create a phony cache entry just to leak. This hack is
177 * primarily to get to the write_entry() machinery that massages
178 * the contents to work-tree format and writes out which only
179 * allows it for a cache entry. The code in write_entry() needs
180 * to be refactored to allow us to feed a <buffer, size, mode>
181 * instead of a cache entry. Such a refactoring would help
182 * merge_recursive as well (it also writes the merge result to the
183 * object database even when it may contain conflicts).
184 */
185 if (write_sha1_file(result_buf.ptr, result_buf.size,
186 blob_type, sha1))
187 die("Unable to add merge result for '%s'", path);
188 ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
189 sha1,
190 path, 2, 0);
191 if (!ce)
192 die("make_cache_entry failed for path '%s'", path);
193 status = checkout_entry(ce, state, NULL);
194 return status;
195 }
197 static int checkout_paths(struct tree *source_tree, const char **pathspec,
198 struct checkout_opts *opts)
199 {
200 int pos;
201 struct checkout state;
202 static char *ps_matched;
203 unsigned char rev[20];
204 int flag;
205 struct commit *head;
206 int errs = 0;
207 int stage = opts->writeout_stage;
208 int merge = opts->merge;
209 int newfd;
210 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
212 newfd = hold_locked_index(lock_file, 1);
213 if (read_cache_preload(pathspec) < 0)
214 return error("corrupt index file");
216 if (source_tree)
217 read_tree_some(source_tree, pathspec);
219 for (pos = 0; pathspec[pos]; pos++)
220 ;
221 ps_matched = xcalloc(1, pos);
223 for (pos = 0; pos < active_nr; pos++) {
224 struct cache_entry *ce = active_cache[pos];
225 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
226 }
228 if (report_path_error(ps_matched, pathspec, 0))
229 return 1;
231 /* "checkout -m path" to recreate conflicted state */
232 if (opts->merge)
233 unmerge_cache(pathspec);
235 /* Any unmerged paths? */
236 for (pos = 0; pos < active_nr; pos++) {
237 struct cache_entry *ce = active_cache[pos];
238 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
239 if (!ce_stage(ce))
240 continue;
241 if (opts->force) {
242 warning("path '%s' is unmerged", ce->name);
243 } else if (stage) {
244 errs |= check_stage(stage, ce, pos);
245 } else if (opts->merge) {
246 errs |= check_all_stages(ce, pos);
247 } else {
248 errs = 1;
249 error("path '%s' is unmerged", ce->name);
250 }
251 pos = skip_same_name(ce, pos) - 1;
252 }
253 }
254 if (errs)
255 return 1;
257 /* Now we are committed to check them out */
258 memset(&state, 0, sizeof(state));
259 state.force = 1;
260 state.refresh_cache = 1;
261 for (pos = 0; pos < active_nr; pos++) {
262 struct cache_entry *ce = active_cache[pos];
263 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
264 if (!ce_stage(ce)) {
265 errs |= checkout_entry(ce, &state, NULL);
266 continue;
267 }
268 if (stage)
269 errs |= checkout_stage(stage, ce, pos, &state);
270 else if (merge)
271 errs |= checkout_merged(pos, &state);
272 pos = skip_same_name(ce, pos) - 1;
273 }
274 }
276 if (write_cache(newfd, active_cache, active_nr) ||
277 commit_locked_index(lock_file))
278 die("unable to write new index file");
280 resolve_ref("HEAD", rev, 0, &flag);
281 head = lookup_commit_reference_gently(rev, 1);
283 errs |= post_checkout_hook(head, head, 0);
284 return errs;
285 }
287 static void show_local_changes(struct object *head, struct diff_options *opts)
288 {
289 struct rev_info rev;
290 /* I think we want full paths, even if we're in a subdirectory. */
291 init_revisions(&rev, NULL);
292 rev.diffopt.flags = opts->flags;
293 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
294 if (diff_setup_done(&rev.diffopt) < 0)
295 die("diff_setup_done failed");
296 add_pending_object(&rev, head, NULL);
297 run_diff_index(&rev, 0);
298 }
300 static void describe_detached_head(char *msg, struct commit *commit)
301 {
302 struct strbuf sb = STRBUF_INIT;
303 struct pretty_print_context ctx = {0};
304 parse_commit(commit);
305 pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
306 fprintf(stderr, "%s %s... %s\n", msg,
307 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
308 strbuf_release(&sb);
309 }
311 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
312 {
313 struct unpack_trees_options opts;
314 struct tree_desc tree_desc;
316 memset(&opts, 0, sizeof(opts));
317 opts.head_idx = -1;
318 opts.update = worktree;
319 opts.skip_unmerged = !worktree;
320 opts.reset = 1;
321 opts.merge = 1;
322 opts.fn = oneway_merge;
323 opts.verbose_update = !o->quiet;
324 opts.src_index = &the_index;
325 opts.dst_index = &the_index;
326 parse_tree(tree);
327 init_tree_desc(&tree_desc, tree->buffer, tree->size);
328 switch (unpack_trees(1, &tree_desc, &opts)) {
329 case -2:
330 o->writeout_error = 1;
331 /*
332 * We return 0 nevertheless, as the index is all right
333 * and more importantly we have made best efforts to
334 * update paths in the work tree, and we cannot revert
335 * them.
336 */
337 case 0:
338 return 0;
339 default:
340 return 128;
341 }
342 }
344 struct branch_info {
345 const char *name; /* The short name used */
346 const char *path; /* The full name of a real branch */
347 struct commit *commit; /* The named commit */
348 };
350 static void setup_branch_path(struct branch_info *branch)
351 {
352 struct strbuf buf = STRBUF_INIT;
354 strbuf_branchname(&buf, branch->name);
355 if (strcmp(buf.buf, branch->name))
356 branch->name = xstrdup(buf.buf);
357 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
358 branch->path = strbuf_detach(&buf, NULL);
359 }
361 static int merge_working_tree(struct checkout_opts *opts,
362 struct branch_info *old, struct branch_info *new)
363 {
364 int ret;
365 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
366 int newfd = hold_locked_index(lock_file, 1);
368 if (read_cache_preload(NULL) < 0)
369 return error("corrupt index file");
371 resolve_undo_clear();
372 if (opts->force) {
373 ret = reset_tree(new->commit->tree, opts, 1);
374 if (ret)
375 return ret;
376 } else {
377 struct tree_desc trees[2];
378 struct tree *tree;
379 struct unpack_trees_options topts;
381 memset(&topts, 0, sizeof(topts));
382 topts.head_idx = -1;
383 topts.src_index = &the_index;
384 topts.dst_index = &the_index;
386 setup_unpack_trees_porcelain(&topts, "checkout");
388 refresh_cache(REFRESH_QUIET);
390 if (unmerged_cache()) {
391 error("you need to resolve your current index first");
392 return 1;
393 }
395 /* 2-way merge to the new branch */
396 topts.initial_checkout = is_cache_unborn();
397 topts.update = 1;
398 topts.merge = 1;
399 topts.gently = opts->merge && old->commit;
400 topts.verbose_update = !opts->quiet;
401 topts.fn = twoway_merge;
402 if (!ignored_are_precious) {
403 topts.dir = xcalloc(1, sizeof(*topts.dir));
404 topts.dir->flags |= DIR_SHOW_IGNORED;
405 topts.dir->exclude_per_dir = ".gitignore";
406 }
407 tree = parse_tree_indirect(old->commit ?
408 old->commit->object.sha1 :
409 (unsigned char *)EMPTY_TREE_SHA1_BIN);
410 init_tree_desc(&trees[0], tree->buffer, tree->size);
411 tree = parse_tree_indirect(new->commit->object.sha1);
412 init_tree_desc(&trees[1], tree->buffer, tree->size);
414 ret = unpack_trees(2, trees, &topts);
415 if (ret == -1) {
416 /*
417 * Unpack couldn't do a trivial merge; either
418 * give up or do a real merge, depending on
419 * whether the merge flag was used.
420 */
421 struct tree *result;
422 struct tree *work;
423 struct merge_options o;
424 if (!opts->merge)
425 return 1;
427 /*
428 * Without old->commit, the below is the same as
429 * the two-tree unpack we already tried and failed.
430 */
431 if (!old->commit)
432 return 1;
434 /* Do more real merge */
436 /*
437 * We update the index fully, then write the
438 * tree from the index, then merge the new
439 * branch with the current tree, with the old
440 * branch as the base. Then we reset the index
441 * (but not the working tree) to the new
442 * branch, leaving the working tree as the
443 * merged version, but skipping unmerged
444 * entries in the index.
445 */
447 add_files_to_cache(NULL, NULL, 0);
448 /*
449 * NEEDSWORK: carrying over local changes
450 * when branches have different end-of-line
451 * normalization (or clean+smudge rules) is
452 * a pain; plumb in an option to set
453 * o.renormalize?
454 */
455 init_merge_options(&o);
456 o.verbosity = 0;
457 work = write_tree_from_memory(&o);
459 ret = reset_tree(new->commit->tree, opts, 1);
460 if (ret)
461 return ret;
462 o.ancestor = old->name;
463 o.branch1 = new->name;
464 o.branch2 = "local";
465 merge_trees(&o, new->commit->tree, work,
466 old->commit->tree, &result);
467 ret = reset_tree(new->commit->tree, opts, 0);
468 if (ret)
469 return ret;
470 }
471 }
473 if (write_cache(newfd, active_cache, active_nr) ||
474 commit_locked_index(lock_file))
475 die("unable to write new index file");
477 if (!opts->force && !opts->quiet)
478 show_local_changes(&new->commit->object, &opts->diff_options);
480 return 0;
481 }
483 static void report_tracking(struct branch_info *new)
484 {
485 struct strbuf sb = STRBUF_INIT;
486 struct branch *branch = branch_get(new->name);
488 if (!format_tracking_info(branch, &sb))
489 return;
490 fputs(sb.buf, stdout);
491 strbuf_release(&sb);
492 }
494 static void detach_advice(const char *old_path, const char *new_name)
495 {
496 const char fmt[] =
497 "Note: checking out '%s'.\n\n"
498 "You are in 'detached HEAD' state. You can look around, make experimental\n"
499 "changes and commit them, and you can discard any commits you make in this\n"
500 "state without impacting any branches by performing another checkout.\n\n"
501 "If you want to create a new branch to retain commits you create, you may\n"
502 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
503 " git checkout -b new_branch_name\n\n";
505 fprintf(stderr, fmt, new_name);
506 }
508 static void update_refs_for_switch(struct checkout_opts *opts,
509 struct branch_info *old,
510 struct branch_info *new)
511 {
512 struct strbuf msg = STRBUF_INIT;
513 const char *old_desc;
514 if (opts->new_branch) {
515 if (opts->new_orphan_branch) {
516 if (opts->new_branch_log && !log_all_ref_updates) {
517 int temp;
518 char log_file[PATH_MAX];
519 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
521 temp = log_all_ref_updates;
522 log_all_ref_updates = 1;
523 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
524 fprintf(stderr, "Can not do reflog for '%s'\n",
525 opts->new_orphan_branch);
526 log_all_ref_updates = temp;
527 return;
528 }
529 log_all_ref_updates = temp;
530 }
531 }
532 else
533 create_branch(old->name, opts->new_branch, new->name,
534 opts->new_branch_force ? 1 : 0,
535 opts->new_branch_log, opts->track);
536 new->name = opts->new_branch;
537 setup_branch_path(new);
538 }
540 old_desc = old->name;
541 if (!old_desc && old->commit)
542 old_desc = sha1_to_hex(old->commit->object.sha1);
543 strbuf_addf(&msg, "checkout: moving from %s to %s",
544 old_desc ? old_desc : "(invalid)", new->name);
546 if (new->path) {
547 create_symref("HEAD", new->path, msg.buf);
548 if (!opts->quiet) {
549 if (old->path && !strcmp(new->path, old->path))
550 fprintf(stderr, "Already on '%s'\n",
551 new->name);
552 else if (opts->new_branch)
553 fprintf(stderr, "Switched to%s branch '%s'\n",
554 opts->branch_exists ? " and reset" : " a new",
555 new->name);
556 else
557 fprintf(stderr, "Switched to branch '%s'\n",
558 new->name);
559 }
560 if (old->path && old->name) {
561 char log_file[PATH_MAX], ref_file[PATH_MAX];
563 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
564 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
565 if (!file_exists(ref_file) && file_exists(log_file))
566 remove_path(log_file);
567 }
568 } else if (strcmp(new->name, "HEAD")) {
569 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
570 REF_NODEREF, DIE_ON_ERR);
571 if (!opts->quiet) {
572 if (old->path && advice_detached_head)
573 detach_advice(old->path, new->name);
574 describe_detached_head("HEAD is now at", new->commit);
575 }
576 }
577 remove_branch_state();
578 strbuf_release(&msg);
579 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
580 report_tracking(new);
581 }
583 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
584 {
585 int ret = 0;
586 struct branch_info old;
587 unsigned char rev[20];
588 int flag;
589 memset(&old, 0, sizeof(old));
590 old.path = resolve_ref("HEAD", rev, 0, &flag);
591 old.commit = lookup_commit_reference_gently(rev, 1);
592 if (!(flag & REF_ISSYMREF))
593 old.path = NULL;
595 if (old.path && !prefixcmp(old.path, "refs/heads/"))
596 old.name = old.path + strlen("refs/heads/");
598 if (!new->name) {
599 new->name = "HEAD";
600 new->commit = old.commit;
601 if (!new->commit)
602 die("You are on a branch yet to be born");
603 parse_commit(new->commit);
604 }
606 ret = merge_working_tree(opts, &old, new);
607 if (ret)
608 return ret;
610 /*
611 * If we were on a detached HEAD, but have now moved to
612 * a new commit, we want to mention the old commit once more
613 * to remind the user that it might be lost.
614 */
615 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
616 describe_detached_head("Previous HEAD position was", old.commit);
618 update_refs_for_switch(opts, &old, new);
620 ret = post_checkout_hook(old.commit, new->commit, 1);
621 return ret || opts->writeout_error;
622 }
624 static int git_checkout_config(const char *var, const char *value, void *cb)
625 {
626 if (!strcmp(var, "diff.ignoresubmodules")) {
627 struct checkout_opts *opts = cb;
628 handle_ignore_submodules_arg(&opts->diff_options, value);
629 return 0;
630 }
632 if (!prefixcmp(var, "submodule."))
633 return parse_submodule_config_option(var, value);
635 return git_xmerge_config(var, value, NULL);
636 }
638 static int interactive_checkout(const char *revision, const char **pathspec,
639 struct checkout_opts *opts)
640 {
641 return run_add_interactive(revision, "--patch=checkout", pathspec);
642 }
644 struct tracking_name_data {
645 const char *name;
646 char *remote;
647 int unique;
648 };
650 static int check_tracking_name(const char *refname, const unsigned char *sha1,
651 int flags, void *cb_data)
652 {
653 struct tracking_name_data *cb = cb_data;
654 const char *slash;
656 if (prefixcmp(refname, "refs/remotes/"))
657 return 0;
658 slash = strchr(refname + 13, '/');
659 if (!slash || strcmp(slash + 1, cb->name))
660 return 0;
661 if (cb->remote) {
662 cb->unique = 0;
663 return 0;
664 }
665 cb->remote = xstrdup(refname);
666 return 0;
667 }
669 static const char *unique_tracking_name(const char *name)
670 {
671 struct tracking_name_data cb_data = { NULL, NULL, 1 };
672 cb_data.name = name;
673 for_each_ref(check_tracking_name, &cb_data);
674 if (cb_data.unique)
675 return cb_data.remote;
676 free(cb_data.remote);
677 return NULL;
678 }
680 int cmd_checkout(int argc, const char **argv, const char *prefix)
681 {
682 struct checkout_opts opts;
683 unsigned char rev[20], branch_rev[20];
684 const char *arg;
685 struct branch_info new;
686 struct tree *source_tree = NULL;
687 char *conflict_style = NULL;
688 int patch_mode = 0;
689 int dwim_new_local_branch = 1;
690 struct option options[] = {
691 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
692 OPT_STRING('b', NULL, &opts.new_branch, "branch",
693 "create and checkout a new branch"),
694 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
695 "create/reset and checkout a branch"),
696 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
697 OPT_SET_INT('t', "track", &opts.track, "set upstream info for new branch",
698 BRANCH_TRACK_EXPLICIT),
699 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
700 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
701 2),
702 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
703 3),
704 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
705 OPT_BOOLEAN('i', "ignored-are-precious", &ignored_are_precious,
706 "fail when an ignored file needs to be overwritten"),
707 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
708 OPT_STRING(0, "conflict", &conflict_style, "style",
709 "conflict style (merge or diff3)"),
710 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
711 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
712 "second guess 'git checkout no-such-branch'",
713 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
714 OPT_END(),
715 };
716 int has_dash_dash;
718 memset(&opts, 0, sizeof(opts));
719 memset(&new, 0, sizeof(new));
721 gitmodules_config();
722 git_config(git_checkout_config, &opts);
724 opts.track = BRANCH_TRACK_UNSPECIFIED;
726 argc = parse_options(argc, argv, prefix, options, checkout_usage,
727 PARSE_OPT_KEEP_DASHDASH);
729 /* we can assume from now on new_branch = !new_branch_force */
730 if (opts.new_branch && opts.new_branch_force)
731 die("-B cannot be used with -b");
733 /* copy -B over to -b, so that we can just check the latter */
734 if (opts.new_branch_force)
735 opts.new_branch = opts.new_branch_force;
737 if (patch_mode && (opts.track > 0 || opts.new_branch
738 || opts.new_branch_log || opts.merge || opts.force))
739 die ("--patch is incompatible with all other options");
741 /* --track without -b should DWIM */
742 if (0 < opts.track && !opts.new_branch) {
743 const char *argv0 = argv[0];
744 if (!argc || !strcmp(argv0, "--"))
745 die ("--track needs a branch name");
746 if (!prefixcmp(argv0, "refs/"))
747 argv0 += 5;
748 if (!prefixcmp(argv0, "remotes/"))
749 argv0 += 8;
750 argv0 = strchr(argv0, '/');
751 if (!argv0 || !argv0[1])
752 die ("Missing branch name; try -b");
753 opts.new_branch = argv0 + 1;
754 }
756 if (opts.new_orphan_branch) {
757 if (opts.new_branch)
758 die("--orphan and -b|-B are mutually exclusive");
759 if (opts.track > 0)
760 die("--orphan cannot be used with -t");
761 opts.new_branch = opts.new_orphan_branch;
762 }
764 if (conflict_style) {
765 opts.merge = 1; /* implied */
766 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
767 }
769 if (opts.force && opts.merge)
770 die("git checkout: -f and -m are incompatible");
772 /*
773 * case 1: git checkout <ref> -- [<paths>]
774 *
775 * <ref> must be a valid tree, everything after the '--' must be
776 * a path.
777 *
778 * case 2: git checkout -- [<paths>]
779 *
780 * everything after the '--' must be paths.
781 *
782 * case 3: git checkout <something> [<paths>]
783 *
784 * With no paths, if <something> is a commit, that is to
785 * switch to the branch or detach HEAD at it. As a special case,
786 * if <something> is A...B (missing A or B means HEAD but you can
787 * omit at most one side), and if there is a unique merge base
788 * between A and B, A...B names that merge base.
789 *
790 * With no paths, if <something> is _not_ a commit, no -t nor -b
791 * was given, and there is a remote-tracking branch whose name is
792 * <something> in one and only one remote, then this is a short-hand
793 * to fork local <something> from that remote-tracking branch.
794 *
795 * Otherwise <something> shall not be ambiguous.
796 * - If it's *only* a reference, treat it like case (1).
797 * - If it's only a path, treat it like case (2).
798 * - else: fail.
799 *
800 */
801 if (argc) {
802 if (!strcmp(argv[0], "--")) { /* case (2) */
803 argv++;
804 argc--;
805 goto no_reference;
806 }
808 arg = argv[0];
809 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
811 if (!strcmp(arg, "-"))
812 arg = "@{-1}";
814 if (get_sha1_mb(arg, rev)) {
815 if (has_dash_dash) /* case (1) */
816 die("invalid reference: %s", arg);
817 if (!patch_mode &&
818 dwim_new_local_branch &&
819 opts.track == BRANCH_TRACK_UNSPECIFIED &&
820 !opts.new_branch &&
821 !check_filename(NULL, arg) &&
822 argc == 1) {
823 const char *remote = unique_tracking_name(arg);
824 if (!remote || get_sha1(remote, rev))
825 goto no_reference;
826 opts.new_branch = arg;
827 arg = remote;
828 /* DWIMmed to create local branch */
829 }
830 else
831 goto no_reference;
832 }
834 /* we can't end up being in (2) anymore, eat the argument */
835 argv++;
836 argc--;
838 new.name = arg;
839 setup_branch_path(&new);
841 if (check_ref_format(new.path) == CHECK_REF_FORMAT_OK &&
842 resolve_ref(new.path, branch_rev, 1, NULL))
843 hashcpy(rev, branch_rev);
844 else
845 new.path = NULL; /* not an existing branch */
847 if (!(new.commit = lookup_commit_reference_gently(rev, 1))) {
848 /* not a commit */
849 source_tree = parse_tree_indirect(rev);
850 } else {
851 parse_commit(new.commit);
852 source_tree = new.commit->tree;
853 }
855 if (!source_tree) /* case (1): want a tree */
856 die("reference is not a tree: %s", arg);
857 if (!has_dash_dash) {/* case (3 -> 1) */
858 /*
859 * Do not complain the most common case
860 * git checkout branch
861 * even if there happen to be a file called 'branch';
862 * it would be extremely annoying.
863 */
864 if (argc)
865 verify_non_filename(NULL, arg);
866 }
867 else {
868 argv++;
869 argc--;
870 }
871 }
873 no_reference:
875 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
876 opts.track = git_branch_track;
878 if (argc) {
879 const char **pathspec = get_pathspec(prefix, argv);
881 if (!pathspec)
882 die("invalid path specification");
884 if (patch_mode)
885 return interactive_checkout(new.name, pathspec, &opts);
887 /* Checkout paths */
888 if (opts.new_branch) {
889 if (argc == 1) {
890 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]);
891 } else {
892 die("git checkout: updating paths is incompatible with switching branches.");
893 }
894 }
896 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
897 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
899 return checkout_paths(source_tree, pathspec, &opts);
900 }
902 if (patch_mode)
903 return interactive_checkout(new.name, NULL, &opts);
905 if (opts.new_branch) {
906 struct strbuf buf = STRBUF_INIT;
907 if (strbuf_check_branch_ref(&buf, opts.new_branch))
908 die("git checkout: we do not like '%s' as a branch name.",
909 opts.new_branch);
910 if (!get_sha1(buf.buf, rev)) {
911 opts.branch_exists = 1;
912 if (!opts.new_branch_force)
913 die("git checkout: branch %s already exists",
914 opts.new_branch);
915 }
916 strbuf_release(&buf);
917 }
919 if (new.name && !new.commit) {
920 die("Cannot switch branch to a non-commit.");
921 }
922 if (opts.writeout_stage)
923 die("--ours/--theirs is incompatible with switching branches.");
925 return switch_branches(&opts, &new);
926 }