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