a0c00d38787ec406b952fbebd057b83f2cae69b6
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 /*
154 * NEEDSWORK: re-create conflicts from merges with
155 * merge.renormalize set, too
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.abbrev = 0;
287 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
288 if (diff_setup_done(&rev.diffopt) < 0)
289 die("diff_setup_done failed");
290 add_pending_object(&rev, head, NULL);
291 run_diff_index(&rev, 0);
292}
293
294static void describe_detached_head(char *msg, struct commit *commit)
295{
296 struct strbuf sb = STRBUF_INIT;
297 struct pretty_print_context ctx = {0};
298 parse_commit(commit);
299 pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
300 fprintf(stderr, "%s %s... %s\n", msg,
301 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
302 strbuf_release(&sb);
303}
304
305static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
306{
307 struct unpack_trees_options opts;
308 struct tree_desc tree_desc;
309
310 memset(&opts, 0, sizeof(opts));
311 opts.head_idx = -1;
312 opts.update = worktree;
313 opts.skip_unmerged = !worktree;
314 opts.reset = 1;
315 opts.merge = 1;
316 opts.fn = oneway_merge;
317 opts.verbose_update = !o->quiet;
318 opts.src_index = &the_index;
319 opts.dst_index = &the_index;
320 parse_tree(tree);
321 init_tree_desc(&tree_desc, tree->buffer, tree->size);
322 switch (unpack_trees(1, &tree_desc, &opts)) {
323 case -2:
324 o->writeout_error = 1;
325 /*
326 * We return 0 nevertheless, as the index is all right
327 * and more importantly we have made best efforts to
328 * update paths in the work tree, and we cannot revert
329 * them.
330 */
331 case 0:
332 return 0;
333 default:
334 return 128;
335 }
336}
337
338struct branch_info {
339 const char *name; /* The short name used */
340 const char *path; /* The full name of a real branch */
341 struct commit *commit; /* The named commit */
342};
343
344static void setup_branch_path(struct branch_info *branch)
345{
346 struct strbuf buf = STRBUF_INIT;
347
348 strbuf_branchname(&buf, branch->name);
349 if (strcmp(buf.buf, branch->name))
350 branch->name = xstrdup(buf.buf);
351 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
352 branch->path = strbuf_detach(&buf, NULL);
353}
354
355static int merge_working_tree(struct checkout_opts *opts,
356 struct branch_info *old, struct branch_info *new)
357{
358 int ret;
359 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
360 int newfd = hold_locked_index(lock_file, 1);
361
362 if (read_cache_preload(NULL) < 0)
363 return error("corrupt index file");
364
365 resolve_undo_clear();
366 if (opts->force) {
367 ret = reset_tree(new->commit->tree, opts, 1);
368 if (ret)
369 return ret;
370 } else {
371 struct tree_desc trees[2];
372 struct tree *tree;
373 struct unpack_trees_options topts;
374
375 memset(&topts, 0, sizeof(topts));
376 topts.head_idx = -1;
377 topts.src_index = &the_index;
378 topts.dst_index = &the_index;
379
380 topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
381
382 refresh_cache(REFRESH_QUIET);
383
384 if (unmerged_cache()) {
385 error("you need to resolve your current index first");
386 return 1;
387 }
388
389 /* 2-way merge to the new branch */
390 topts.initial_checkout = is_cache_unborn();
391 topts.update = 1;
392 topts.merge = 1;
393 topts.gently = opts->merge && old->commit;
394 topts.verbose_update = !opts->quiet;
395 topts.fn = twoway_merge;
396 topts.dir = xcalloc(1, sizeof(*topts.dir));
397 topts.dir->flags |= DIR_SHOW_IGNORED;
398 topts.dir->exclude_per_dir = ".gitignore";
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, 0,
519 opts->new_branch_log, opts->track);
520 new->name = opts->new_branch;
521 setup_branch_path(new);
522 }
523
524 old_desc = old->name;
525 if (!old_desc && old->commit)
526 old_desc = sha1_to_hex(old->commit->object.sha1);
527 strbuf_addf(&msg, "checkout: moving from %s to %s",
528 old_desc ? old_desc : "(invalid)", new->name);
529
530 if (new->path) {
531 create_symref("HEAD", new->path, msg.buf);
532 if (!opts->quiet) {
533 if (old->path && !strcmp(new->path, old->path))
534 fprintf(stderr, "Already on '%s'\n",
535 new->name);
536 else
537 fprintf(stderr, "Switched to%s branch '%s'\n",
538 opts->new_branch ? " a new" : "",
539 new->name);
540 }
541 if (old->path && old->name) {
542 char log_file[PATH_MAX], ref_file[PATH_MAX];
543
544 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
545 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
546 if (!file_exists(ref_file) && file_exists(log_file))
547 remove_path(log_file);
548 }
549 } else if (strcmp(new->name, "HEAD")) {
550 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
551 REF_NODEREF, DIE_ON_ERR);
552 if (!opts->quiet) {
553 if (old->path && advice_detached_head)
554 detach_advice(old->path, new->name);
555 describe_detached_head("HEAD is now at", new->commit);
556 }
557 }
558 remove_branch_state();
559 strbuf_release(&msg);
560 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
561 report_tracking(new);
562}
563
564static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
565{
566 int ret = 0;
567 struct branch_info old;
568 unsigned char rev[20];
569 int flag;
570 memset(&old, 0, sizeof(old));
571 old.path = resolve_ref("HEAD", rev, 0, &flag);
572 old.commit = lookup_commit_reference_gently(rev, 1);
573 if (!(flag & REF_ISSYMREF))
574 old.path = NULL;
575
576 if (old.path && !prefixcmp(old.path, "refs/heads/"))
577 old.name = old.path + strlen("refs/heads/");
578
579 if (!new->name) {
580 new->name = "HEAD";
581 new->commit = old.commit;
582 if (!new->commit)
583 die("You are on a branch yet to be born");
584 parse_commit(new->commit);
585 }
586
587 ret = merge_working_tree(opts, &old, new);
588 if (ret)
589 return ret;
590
591 /*
592 * If we were on a detached HEAD, but have now moved to
593 * a new commit, we want to mention the old commit once more
594 * to remind the user that it might be lost.
595 */
596 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
597 describe_detached_head("Previous HEAD position was", old.commit);
598
599 update_refs_for_switch(opts, &old, new);
600
601 ret = post_checkout_hook(old.commit, new->commit, 1);
602 return ret || opts->writeout_error;
603}
604
605static int git_checkout_config(const char *var, const char *value, void *cb)
606{
607 return git_xmerge_config(var, value, cb);
608}
609
610static int interactive_checkout(const char *revision, const char **pathspec,
611 struct checkout_opts *opts)
612{
613 return run_add_interactive(revision, "--patch=checkout", pathspec);
614}
615
616struct tracking_name_data {
617 const char *name;
618 char *remote;
619 int unique;
620};
621
622static int check_tracking_name(const char *refname, const unsigned char *sha1,
623 int flags, void *cb_data)
624{
625 struct tracking_name_data *cb = cb_data;
626 const char *slash;
627
628 if (prefixcmp(refname, "refs/remotes/"))
629 return 0;
630 slash = strchr(refname + 13, '/');
631 if (!slash || strcmp(slash + 1, cb->name))
632 return 0;
633 if (cb->remote) {
634 cb->unique = 0;
635 return 0;
636 }
637 cb->remote = xstrdup(refname);
638 return 0;
639}
640
641static const char *unique_tracking_name(const char *name)
642{
643 struct tracking_name_data cb_data = { NULL, NULL, 1 };
644 cb_data.name = name;
645 for_each_ref(check_tracking_name, &cb_data);
646 if (cb_data.unique)
647 return cb_data.remote;
648 free(cb_data.remote);
649 return NULL;
650}
651
652int cmd_checkout(int argc, const char **argv, const char *prefix)
653{
654 struct checkout_opts opts;
655 unsigned char rev[20];
656 const char *arg;
657 struct branch_info new;
658 struct tree *source_tree = NULL;
659 char *conflict_style = NULL;
660 int patch_mode = 0;
661 int dwim_new_local_branch = 1;
662 struct option options[] = {
663 OPT__QUIET(&opts.quiet),
664 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
665 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
666 OPT_SET_INT('t', "track", &opts.track, "track",
667 BRANCH_TRACK_EXPLICIT),
668 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
669 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
670 2),
671 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
672 3),
673 OPT_BOOLEAN('f', "force", &opts.force, "force"),
674 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
675 OPT_STRING(0, "conflict", &conflict_style, "style",
676 "conflict style (merge or diff3)"),
677 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
678 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
679 "second guess 'git checkout no-such-branch'",
680 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
681 OPT_END(),
682 };
683 int has_dash_dash;
684
685 memset(&opts, 0, sizeof(opts));
686 memset(&new, 0, sizeof(new));
687
688 git_config(git_checkout_config, NULL);
689
690 opts.track = BRANCH_TRACK_UNSPECIFIED;
691
692 argc = parse_options(argc, argv, prefix, options, checkout_usage,
693 PARSE_OPT_KEEP_DASHDASH);
694
695 if (patch_mode && (opts.track > 0 || opts.new_branch
696 || opts.new_branch_log || opts.merge || opts.force))
697 die ("--patch is incompatible with all other options");
698
699 /* --track without -b should DWIM */
700 if (0 < opts.track && !opts.new_branch) {
701 const char *argv0 = argv[0];
702 if (!argc || !strcmp(argv0, "--"))
703 die ("--track needs a branch name");
704 if (!prefixcmp(argv0, "refs/"))
705 argv0 += 5;
706 if (!prefixcmp(argv0, "remotes/"))
707 argv0 += 8;
708 argv0 = strchr(argv0, '/');
709 if (!argv0 || !argv0[1])
710 die ("Missing branch name; try -b");
711 opts.new_branch = argv0 + 1;
712 }
713
714 if (opts.new_orphan_branch) {
715 if (opts.new_branch)
716 die("--orphan and -b are mutually exclusive");
717 if (opts.track > 0)
718 die("--orphan cannot be used with -t");
719 opts.new_branch = opts.new_orphan_branch;
720 }
721
722 if (conflict_style) {
723 opts.merge = 1; /* implied */
724 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
725 }
726
727 if (opts.force && opts.merge)
728 die("git checkout: -f and -m are incompatible");
729
730 /*
731 * case 1: git checkout <ref> -- [<paths>]
732 *
733 * <ref> must be a valid tree, everything after the '--' must be
734 * a path.
735 *
736 * case 2: git checkout -- [<paths>]
737 *
738 * everything after the '--' must be paths.
739 *
740 * case 3: git checkout <something> [<paths>]
741 *
742 * With no paths, if <something> is a commit, that is to
743 * switch to the branch or detach HEAD at it. As a special case,
744 * if <something> is A...B (missing A or B means HEAD but you can
745 * omit at most one side), and if there is a unique merge base
746 * between A and B, A...B names that merge base.
747 *
748 * With no paths, if <something> is _not_ a commit, no -t nor -b
749 * was given, and there is a tracking branch whose name is
750 * <something> in one and only one remote, then this is a short-hand
751 * to fork local <something> from that remote tracking branch.
752 *
753 * Otherwise <something> shall not be ambiguous.
754 * - If it's *only* a reference, treat it like case (1).
755 * - If it's only a path, treat it like case (2).
756 * - else: fail.
757 *
758 */
759 if (argc) {
760 if (!strcmp(argv[0], "--")) { /* case (2) */
761 argv++;
762 argc--;
763 goto no_reference;
764 }
765
766 arg = argv[0];
767 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
768
769 if (!strcmp(arg, "-"))
770 arg = "@{-1}";
771
772 if (get_sha1_mb(arg, rev)) {
773 if (has_dash_dash) /* case (1) */
774 die("invalid reference: %s", arg);
775 if (!patch_mode &&
776 dwim_new_local_branch &&
777 opts.track == BRANCH_TRACK_UNSPECIFIED &&
778 !opts.new_branch &&
779 !check_filename(NULL, arg) &&
780 argc == 1) {
781 const char *remote = unique_tracking_name(arg);
782 if (!remote || get_sha1(remote, rev))
783 goto no_reference;
784 opts.new_branch = arg;
785 arg = remote;
786 /* DWIMmed to create local branch */
787 }
788 else
789 goto no_reference;
790 }
791
792 /* we can't end up being in (2) anymore, eat the argument */
793 argv++;
794 argc--;
795
796 new.name = arg;
797 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
798 setup_branch_path(&new);
799
800 if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
801 resolve_ref(new.path, rev, 1, NULL))
802 ;
803 else
804 new.path = NULL;
805 parse_commit(new.commit);
806 source_tree = new.commit->tree;
807 } else
808 source_tree = parse_tree_indirect(rev);
809
810 if (!source_tree) /* case (1): want a tree */
811 die("reference is not a tree: %s", arg);
812 if (!has_dash_dash) {/* case (3 -> 1) */
813 /*
814 * Do not complain the most common case
815 * git checkout branch
816 * even if there happen to be a file called 'branch';
817 * it would be extremely annoying.
818 */
819 if (argc)
820 verify_non_filename(NULL, arg);
821 }
822 else {
823 argv++;
824 argc--;
825 }
826 }
827
828no_reference:
829
830 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
831 opts.track = git_branch_track;
832
833 if (argc) {
834 const char **pathspec = get_pathspec(prefix, argv);
835
836 if (!pathspec)
837 die("invalid path specification");
838
839 if (patch_mode)
840 return interactive_checkout(new.name, pathspec, &opts);
841
842 /* Checkout paths */
843 if (opts.new_branch) {
844 if (argc == 1) {
845 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]);
846 } else {
847 die("git checkout: updating paths is incompatible with switching branches.");
848 }
849 }
850
851 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
852 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
853
854 return checkout_paths(source_tree, pathspec, &opts);
855 }
856
857 if (patch_mode)
858 return interactive_checkout(new.name, NULL, &opts);
859
860 if (opts.new_branch) {
861 struct strbuf buf = STRBUF_INIT;
862 if (strbuf_check_branch_ref(&buf, opts.new_branch))
863 die("git checkout: we do not like '%s' as a branch name.",
864 opts.new_branch);
865 if (!get_sha1(buf.buf, rev))
866 die("git checkout: branch %s already exists", opts.new_branch);
867 strbuf_release(&buf);
868 }
869
870 if (new.name && !new.commit) {
871 die("Cannot switch branch to a non-commit.");
872 }
873 if (opts.writeout_stage)
874 die("--ours/--theirs is incompatible with switching branches.");
875
876 return switch_branches(&opts, &new);
877}