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