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