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