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