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