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