unpack_trees: group error messages by type
[git/git.git] / builtin / checkout.c
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
22 static const char * const checkout_usage[] = {
23 "git checkout [options] <branch>",
24 "git checkout [options] [<branch>] -- <file>...",
25 NULL,
26 };
27
28 struct 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
41 static 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
53 static 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
73 static 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
84 static 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
92 static 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
105 static 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
118 static 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
132 static 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, "base",
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
187 static 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
277 static 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
290 static 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
301 static 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
334 struct 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
340 static 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
351 static 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 set_porcelain_error_msgs(topts.msgs, "checkout");
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 topts.show_all_errors = 1;
396 tree = parse_tree_indirect(old->commit ?
397 old->commit->object.sha1 :
398 (unsigned char *)EMPTY_TREE_SHA1_BIN);
399 init_tree_desc(&trees[0], tree->buffer, tree->size);
400 tree = parse_tree_indirect(new->commit->object.sha1);
401 init_tree_desc(&trees[1], tree->buffer, tree->size);
402
403 ret = unpack_trees(2, trees, &topts);
404 if (ret == -1) {
405 /*
406 * Unpack couldn't do a trivial merge; either
407 * give up or do a real merge, depending on
408 * whether the merge flag was used.
409 */
410 struct tree *result;
411 struct tree *work;
412 struct merge_options o;
413 if (!opts->merge)
414 return 1;
415
416 /*
417 * Without old->commit, the below is the same as
418 * the two-tree unpack we already tried and failed.
419 */
420 if (!old->commit)
421 return 1;
422
423 /* Do more real merge */
424
425 /*
426 * We update the index fully, then write the
427 * tree from the index, then merge the new
428 * branch with the current tree, with the old
429 * branch as the base. Then we reset the index
430 * (but not the working tree) to the new
431 * branch, leaving the working tree as the
432 * merged version, but skipping unmerged
433 * entries in the index.
434 */
435
436 add_files_to_cache(NULL, NULL, 0);
437 init_merge_options(&o);
438 o.verbosity = 0;
439 work = write_tree_from_memory(&o);
440
441 ret = reset_tree(new->commit->tree, opts, 1);
442 if (ret)
443 return ret;
444 o.ancestor = old->name;
445 o.branch1 = new->name;
446 o.branch2 = "local";
447 merge_trees(&o, new->commit->tree, work,
448 old->commit->tree, &result);
449 ret = reset_tree(new->commit->tree, opts, 0);
450 if (ret)
451 return ret;
452 }
453 }
454
455 if (write_cache(newfd, active_cache, active_nr) ||
456 commit_locked_index(lock_file))
457 die("unable to write new index file");
458
459 if (!opts->force && !opts->quiet)
460 show_local_changes(&new->commit->object);
461
462 return 0;
463 }
464
465 static void report_tracking(struct branch_info *new)
466 {
467 struct strbuf sb = STRBUF_INIT;
468 struct branch *branch = branch_get(new->name);
469
470 if (!format_tracking_info(branch, &sb))
471 return;
472 fputs(sb.buf, stdout);
473 strbuf_release(&sb);
474 }
475
476 static void detach_advice(const char *old_path, const char *new_name)
477 {
478 const char fmt[] =
479 "Note: checking out '%s'.\n\n"
480 "You are in 'detached HEAD' state. You can look around, make experimental\n"
481 "changes and commit them, and you can discard any commits you make in this\n"
482 "state without impacting any branches by performing another checkout.\n\n"
483 "If you want to create a new branch to retain commits you create, you may\n"
484 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
485 " git checkout -b new_branch_name\n\n";
486
487 fprintf(stderr, fmt, new_name);
488 }
489
490 static void update_refs_for_switch(struct checkout_opts *opts,
491 struct branch_info *old,
492 struct branch_info *new)
493 {
494 struct strbuf msg = STRBUF_INIT;
495 const char *old_desc;
496 if (opts->new_branch) {
497 if (opts->new_orphan_branch) {
498 if (opts->new_branch_log && !log_all_ref_updates) {
499 int temp;
500 char log_file[PATH_MAX];
501 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
502
503 temp = log_all_ref_updates;
504 log_all_ref_updates = 1;
505 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
506 fprintf(stderr, "Can not do reflog for '%s'\n",
507 opts->new_orphan_branch);
508 log_all_ref_updates = temp;
509 return;
510 }
511 log_all_ref_updates = temp;
512 }
513 }
514 else
515 create_branch(old->name, opts->new_branch, new->name, 0,
516 opts->new_branch_log, opts->track);
517 new->name = opts->new_branch;
518 setup_branch_path(new);
519 }
520
521 old_desc = old->name;
522 if (!old_desc && old->commit)
523 old_desc = sha1_to_hex(old->commit->object.sha1);
524 strbuf_addf(&msg, "checkout: moving from %s to %s",
525 old_desc ? old_desc : "(invalid)", new->name);
526
527 if (new->path) {
528 create_symref("HEAD", new->path, msg.buf);
529 if (!opts->quiet) {
530 if (old->path && !strcmp(new->path, old->path))
531 fprintf(stderr, "Already on '%s'\n",
532 new->name);
533 else
534 fprintf(stderr, "Switched to%s branch '%s'\n",
535 opts->new_branch ? " a new" : "",
536 new->name);
537 }
538 if (old->path && old->name) {
539 char log_file[PATH_MAX], ref_file[PATH_MAX];
540
541 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
542 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
543 if (!file_exists(ref_file) && file_exists(log_file))
544 remove_path(log_file);
545 }
546 } else if (strcmp(new->name, "HEAD")) {
547 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
548 REF_NODEREF, DIE_ON_ERR);
549 if (!opts->quiet) {
550 if (old->path && advice_detached_head)
551 detach_advice(old->path, new->name);
552 describe_detached_head("HEAD is now at", new->commit);
553 }
554 }
555 remove_branch_state();
556 strbuf_release(&msg);
557 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
558 report_tracking(new);
559 }
560
561 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
562 {
563 int ret = 0;
564 struct branch_info old;
565 unsigned char rev[20];
566 int flag;
567 memset(&old, 0, sizeof(old));
568 old.path = resolve_ref("HEAD", rev, 0, &flag);
569 old.commit = lookup_commit_reference_gently(rev, 1);
570 if (!(flag & REF_ISSYMREF))
571 old.path = NULL;
572
573 if (old.path && !prefixcmp(old.path, "refs/heads/"))
574 old.name = old.path + strlen("refs/heads/");
575
576 if (!new->name) {
577 new->name = "HEAD";
578 new->commit = old.commit;
579 if (!new->commit)
580 die("You are on a branch yet to be born");
581 parse_commit(new->commit);
582 }
583
584 ret = merge_working_tree(opts, &old, new);
585 if (ret)
586 return ret;
587
588 /*
589 * If we were on a detached HEAD, but have now moved to
590 * a new commit, we want to mention the old commit once more
591 * to remind the user that it might be lost.
592 */
593 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
594 describe_detached_head("Previous HEAD position was", old.commit);
595
596 update_refs_for_switch(opts, &old, new);
597
598 ret = post_checkout_hook(old.commit, new->commit, 1);
599 return ret || opts->writeout_error;
600 }
601
602 static int git_checkout_config(const char *var, const char *value, void *cb)
603 {
604 return git_xmerge_config(var, value, cb);
605 }
606
607 static int interactive_checkout(const char *revision, const char **pathspec,
608 struct checkout_opts *opts)
609 {
610 return run_add_interactive(revision, "--patch=checkout", pathspec);
611 }
612
613 struct tracking_name_data {
614 const char *name;
615 char *remote;
616 int unique;
617 };
618
619 static int check_tracking_name(const char *refname, const unsigned char *sha1,
620 int flags, void *cb_data)
621 {
622 struct tracking_name_data *cb = cb_data;
623 const char *slash;
624
625 if (prefixcmp(refname, "refs/remotes/"))
626 return 0;
627 slash = strchr(refname + 13, '/');
628 if (!slash || strcmp(slash + 1, cb->name))
629 return 0;
630 if (cb->remote) {
631 cb->unique = 0;
632 return 0;
633 }
634 cb->remote = xstrdup(refname);
635 return 0;
636 }
637
638 static const char *unique_tracking_name(const char *name)
639 {
640 struct tracking_name_data cb_data = { NULL, NULL, 1 };
641 cb_data.name = name;
642 for_each_ref(check_tracking_name, &cb_data);
643 if (cb_data.unique)
644 return cb_data.remote;
645 free(cb_data.remote);
646 return NULL;
647 }
648
649 int cmd_checkout(int argc, const char **argv, const char *prefix)
650 {
651 struct checkout_opts opts;
652 unsigned char rev[20];
653 const char *arg;
654 struct branch_info new;
655 struct tree *source_tree = NULL;
656 char *conflict_style = NULL;
657 int patch_mode = 0;
658 int dwim_new_local_branch = 1;
659 struct option options[] = {
660 OPT__QUIET(&opts.quiet),
661 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
662 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
663 OPT_SET_INT('t', "track", &opts.track, "track",
664 BRANCH_TRACK_EXPLICIT),
665 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
666 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
667 2),
668 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
669 3),
670 OPT_BOOLEAN('f', "force", &opts.force, "force"),
671 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
672 OPT_STRING(0, "conflict", &conflict_style, "style",
673 "conflict style (merge or diff3)"),
674 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
675 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
676 "second guess 'git checkout no-such-branch'",
677 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
678 OPT_END(),
679 };
680 int has_dash_dash;
681
682 memset(&opts, 0, sizeof(opts));
683 memset(&new, 0, sizeof(new));
684
685 git_config(git_checkout_config, NULL);
686
687 opts.track = BRANCH_TRACK_UNSPECIFIED;
688
689 argc = parse_options(argc, argv, prefix, options, checkout_usage,
690 PARSE_OPT_KEEP_DASHDASH);
691
692 if (patch_mode && (opts.track > 0 || opts.new_branch
693 || opts.new_branch_log || opts.merge || opts.force))
694 die ("--patch is incompatible with all other options");
695
696 /* --track without -b should DWIM */
697 if (0 < opts.track && !opts.new_branch) {
698 const char *argv0 = argv[0];
699 if (!argc || !strcmp(argv0, "--"))
700 die ("--track needs a branch name");
701 if (!prefixcmp(argv0, "refs/"))
702 argv0 += 5;
703 if (!prefixcmp(argv0, "remotes/"))
704 argv0 += 8;
705 argv0 = strchr(argv0, '/');
706 if (!argv0 || !argv0[1])
707 die ("Missing branch name; try -b");
708 opts.new_branch = argv0 + 1;
709 }
710
711 if (opts.new_orphan_branch) {
712 if (opts.new_branch)
713 die("--orphan and -b are mutually exclusive");
714 if (opts.track > 0)
715 die("--orphan cannot be used with -t");
716 opts.new_branch = opts.new_orphan_branch;
717 }
718
719 if (conflict_style) {
720 opts.merge = 1; /* implied */
721 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
722 }
723
724 if (opts.force && opts.merge)
725 die("git checkout: -f and -m are incompatible");
726
727 /*
728 * case 1: git checkout <ref> -- [<paths>]
729 *
730 * <ref> must be a valid tree, everything after the '--' must be
731 * a path.
732 *
733 * case 2: git checkout -- [<paths>]
734 *
735 * everything after the '--' must be paths.
736 *
737 * case 3: git checkout <something> [<paths>]
738 *
739 * With no paths, if <something> is a commit, that is to
740 * switch to the branch or detach HEAD at it. As a special case,
741 * if <something> is A...B (missing A or B means HEAD but you can
742 * omit at most one side), and if there is a unique merge base
743 * between A and B, A...B names that merge base.
744 *
745 * With no paths, if <something> is _not_ a commit, no -t nor -b
746 * was given, and there is a tracking branch whose name is
747 * <something> in one and only one remote, then this is a short-hand
748 * to fork local <something> from that remote tracking branch.
749 *
750 * Otherwise <something> shall not be ambiguous.
751 * - If it's *only* a reference, treat it like case (1).
752 * - If it's only a path, treat it like case (2).
753 * - else: fail.
754 *
755 */
756 if (argc) {
757 if (!strcmp(argv[0], "--")) { /* case (2) */
758 argv++;
759 argc--;
760 goto no_reference;
761 }
762
763 arg = argv[0];
764 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
765
766 if (!strcmp(arg, "-"))
767 arg = "@{-1}";
768
769 if (get_sha1_mb(arg, rev)) {
770 if (has_dash_dash) /* case (1) */
771 die("invalid reference: %s", arg);
772 if (!patch_mode &&
773 dwim_new_local_branch &&
774 opts.track == BRANCH_TRACK_UNSPECIFIED &&
775 !opts.new_branch &&
776 !check_filename(NULL, arg) &&
777 argc == 1) {
778 const char *remote = unique_tracking_name(arg);
779 if (!remote || get_sha1(remote, rev))
780 goto no_reference;
781 opts.new_branch = arg;
782 arg = remote;
783 /* DWIMmed to create local branch */
784 }
785 else
786 goto no_reference;
787 }
788
789 /* we can't end up being in (2) anymore, eat the argument */
790 argv++;
791 argc--;
792
793 new.name = arg;
794 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
795 setup_branch_path(&new);
796
797 if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
798 resolve_ref(new.path, rev, 1, NULL))
799 ;
800 else
801 new.path = NULL;
802 parse_commit(new.commit);
803 source_tree = new.commit->tree;
804 } else
805 source_tree = parse_tree_indirect(rev);
806
807 if (!source_tree) /* case (1): want a tree */
808 die("reference is not a tree: %s", arg);
809 if (!has_dash_dash) {/* case (3 -> 1) */
810 /*
811 * Do not complain the most common case
812 * git checkout branch
813 * even if there happen to be a file called 'branch';
814 * it would be extremely annoying.
815 */
816 if (argc)
817 verify_non_filename(NULL, arg);
818 }
819 else {
820 argv++;
821 argc--;
822 }
823 }
824
825 no_reference:
826
827 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
828 opts.track = git_branch_track;
829
830 if (argc) {
831 const char **pathspec = get_pathspec(prefix, argv);
832
833 if (!pathspec)
834 die("invalid path specification");
835
836 if (patch_mode)
837 return interactive_checkout(new.name, pathspec, &opts);
838
839 /* Checkout paths */
840 if (opts.new_branch) {
841 if (argc == 1) {
842 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]);
843 } else {
844 die("git checkout: updating paths is incompatible with switching branches.");
845 }
846 }
847
848 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
849 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
850
851 return checkout_paths(source_tree, pathspec, &opts);
852 }
853
854 if (patch_mode)
855 return interactive_checkout(new.name, NULL, &opts);
856
857 if (opts.new_branch) {
858 struct strbuf buf = STRBUF_INIT;
859 if (strbuf_check_branch_ref(&buf, opts.new_branch))
860 die("git checkout: we do not like '%s' as a branch name.",
861 opts.new_branch);
862 if (!get_sha1(buf.buf, rev))
863 die("git checkout: branch %s already exists", opts.new_branch);
864 strbuf_release(&buf);
865 }
866
867 if (new.name && !new.commit) {
868 die("Cannot switch branch to a non-commit.");
869 }
870 if (opts.writeout_stage)
871 die("--ours/--theirs is incompatible with switching branches.");
872
873 return switch_branches(&opts, &new);
874 }