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