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