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