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