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