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