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