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