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