Merge branch 'maint'
[git.git] / builtin-checkout.c
blobacefaaf41a4e26e45225f6d228734c93c8f2b23c
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"
22 static const char * const checkout_usage[] = {
23 "git checkout [options] <branch>",
24 "git checkout [options] [<branch>] -- <file>...",
25 NULL,
28 struct checkout_opts {
29 int quiet;
30 int merge;
31 int force;
32 int writeout_stage;
33 int writeout_error;
35 const char *new_branch;
36 int new_branch_log;
37 enum branch_track track;
40 static int post_checkout_hook(struct commit *old, struct commit *new,
41 int changed)
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. */
52 static int update_some(const unsigned char *sha1, const char *base, int baselen,
53 const char *pathname, unsigned mode, int stage, void *context)
55 int len;
56 struct cache_entry *ce;
58 if (S_ISDIR(mode))
59 return READ_TREE_RECURSIVE;
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;
72 static int read_tree_some(struct tree *tree, const char **pathspec)
74 read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
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.
80 return 0;
83 static int skip_same_name(struct cache_entry *ce, int pos)
85 while (++pos < active_nr &&
86 !strcmp(active_cache[pos]->name, ce->name))
87 ; /* skip */
88 return pos;
91 static int check_stage(int stage, struct cache_entry *ce, int pos)
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++;
99 return error("path '%s' does not have %s version",
100 ce->name,
101 (stage == 2) ? "our" : "their");
104 static int check_all_stages(struct cache_entry *ce, int pos)
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;
117 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
118 struct checkout *state)
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++;
126 return error("path '%s' does not have %s version",
127 ce->name,
128 (stage == 2) ? "our" : "their");
131 static int checkout_merged(int pos, struct checkout *state)
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;
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);
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);
152 status = ll_merge(&result_buf, path, &ancestor,
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);
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).
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;
186 static int checkout_paths(struct tree *source_tree, const char **pathspec,
187 struct checkout_opts *opts)
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));
201 newfd = hold_locked_index(lock_file, 1);
202 if (read_cache_preload(pathspec) < 0)
203 return error("corrupt index file");
205 if (source_tree)
206 read_tree_some(source_tree, pathspec);
208 for (pos = 0; pathspec[pos]; pos++)
210 ps_matched = xcalloc(1, pos);
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);
217 if (report_path_error(ps_matched, pathspec, 0))
218 return 1;
220 /* "checkout -m path" to recreate conflicted state */
221 if (opts->merge)
222 unmerge_cache(pathspec);
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);
240 pos = skip_same_name(ce, pos) - 1;
243 if (errs)
244 return 1;
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;
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;
265 if (write_cache(newfd, active_cache, active_nr) ||
266 commit_locked_index(lock_file))
267 die("unable to write new index file");
269 resolve_ref("HEAD", rev, 0, &flag);
270 head = lookup_commit_reference_gently(rev, 1);
272 errs |= post_checkout_hook(head, head, 0);
273 return errs;
276 static void show_local_changes(struct object *head)
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);
289 static void describe_detached_head(char *msg, struct commit *commit)
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);
300 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
302 struct unpack_trees_options opts;
303 struct tree_desc tree_desc;
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;
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.
326 case 0:
327 return 0;
328 default:
329 return 128;
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 */
339 static void setup_branch_path(struct branch_info *branch)
341 struct strbuf buf = STRBUF_INIT;
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);
350 static int merge_working_tree(struct checkout_opts *opts,
351 struct branch_info *old, struct branch_info *new)
353 int ret;
354 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
355 int newfd = hold_locked_index(lock_file, 1);
357 if (read_cache_preload(NULL) < 0)
358 return error("corrupt index file");
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;
370 memset(&topts, 0, sizeof(topts));
371 topts.head_idx = -1;
372 topts.src_index = &the_index;
373 topts.dst_index = &the_index;
375 topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
377 refresh_cache(REFRESH_QUIET);
379 if (unmerged_cache()) {
380 error("you need to resolve your current index first");
381 return 1;
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);
401 ret = unpack_trees(2, trees, &topts);
402 if (ret == -1) {
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.
408 struct tree *result;
409 struct tree *work;
410 struct merge_options o;
411 if (!opts->merge)
412 return 1;
415 * Without old->commit, the below is the same as
416 * the two-tree unpack we already tried and failed.
418 if (!old->commit)
419 return 1;
421 /* Do more real merge */
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.
434 add_files_to_cache(NULL, NULL, 0);
435 init_merge_options(&o);
436 o.verbosity = 0;
437 work = write_tree_from_memory(&o);
439 ret = reset_tree(new->commit->tree, opts, 1);
440 if (ret)
441 return ret;
442 o.branch1 = new->name;
443 o.branch2 = "local";
444 merge_trees(&o, new->commit->tree, work,
445 old->commit->tree, &result);
446 ret = reset_tree(new->commit->tree, opts, 0);
447 if (ret)
448 return ret;
452 if (write_cache(newfd, active_cache, active_nr) ||
453 commit_locked_index(lock_file))
454 die("unable to write new index file");
456 if (!opts->force && !opts->quiet)
457 show_local_changes(&new->commit->object);
459 return 0;
462 static void report_tracking(struct branch_info *new)
464 struct strbuf sb = STRBUF_INIT;
465 struct branch *branch = branch_get(new->name);
467 if (!format_tracking_info(branch, &sb))
468 return;
469 fputs(sb.buf, stdout);
470 strbuf_release(&sb);
473 static void detach_advice(const char *old_path, const char *new_name)
475 const char fmt[] =
476 "Note: checking out '%s'.\n\n"
477 "You are in 'detached HEAD' state. You can look around, make experimental\n"
478 "changes and commit them, and you can discard any commits you make in this\n"
479 "state without impacting any branches by performing another checkout.\n\n"
480 "If you want to create a new branch to retain commits you create, you may\n"
481 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
482 " git checkout -b new_branch_name\n\n";
484 fprintf(stderr, fmt, new_name);
487 static void update_refs_for_switch(struct checkout_opts *opts,
488 struct branch_info *old,
489 struct branch_info *new)
491 struct strbuf msg = STRBUF_INIT;
492 const char *old_desc;
493 if (opts->new_branch) {
494 create_branch(old->name, opts->new_branch, new->name, 0,
495 opts->new_branch_log, opts->track);
496 new->name = opts->new_branch;
497 setup_branch_path(new);
500 old_desc = old->name;
501 if (!old_desc && old->commit)
502 old_desc = sha1_to_hex(old->commit->object.sha1);
503 strbuf_addf(&msg, "checkout: moving from %s to %s",
504 old_desc ? old_desc : "(invalid)", new->name);
506 if (new->path) {
507 create_symref("HEAD", new->path, msg.buf);
508 if (!opts->quiet) {
509 if (old->path && !strcmp(new->path, old->path))
510 fprintf(stderr, "Already on '%s'\n",
511 new->name);
512 else
513 fprintf(stderr, "Switched to%s branch '%s'\n",
514 opts->new_branch ? " a new" : "",
515 new->name);
517 } else if (strcmp(new->name, "HEAD")) {
518 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
519 REF_NODEREF, DIE_ON_ERR);
520 if (!opts->quiet) {
521 if (old->path && advice_detached_head)
522 detach_advice(old->path, new->name);
523 describe_detached_head("HEAD is now at", new->commit);
526 remove_branch_state();
527 strbuf_release(&msg);
528 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
529 report_tracking(new);
532 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
534 int ret = 0;
535 struct branch_info old;
536 unsigned char rev[20];
537 int flag;
538 memset(&old, 0, sizeof(old));
539 old.path = resolve_ref("HEAD", rev, 0, &flag);
540 old.commit = lookup_commit_reference_gently(rev, 1);
541 if (!(flag & REF_ISSYMREF))
542 old.path = NULL;
544 if (old.path && !prefixcmp(old.path, "refs/heads/"))
545 old.name = old.path + strlen("refs/heads/");
547 if (!new->name) {
548 new->name = "HEAD";
549 new->commit = old.commit;
550 if (!new->commit)
551 die("You are on a branch yet to be born");
552 parse_commit(new->commit);
555 ret = merge_working_tree(opts, &old, new);
556 if (ret)
557 return ret;
560 * If we were on a detached HEAD, but have now moved to
561 * a new commit, we want to mention the old commit once more
562 * to remind the user that it might be lost.
564 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
565 describe_detached_head("Previous HEAD position was", old.commit);
567 update_refs_for_switch(opts, &old, new);
569 ret = post_checkout_hook(old.commit, new->commit, 1);
570 return ret || opts->writeout_error;
573 static int git_checkout_config(const char *var, const char *value, void *cb)
575 return git_xmerge_config(var, value, cb);
578 static int interactive_checkout(const char *revision, const char **pathspec,
579 struct checkout_opts *opts)
581 return run_add_interactive(revision, "--patch=checkout", pathspec);
584 struct tracking_name_data {
585 const char *name;
586 char *remote;
587 int unique;
590 static int check_tracking_name(const char *refname, const unsigned char *sha1,
591 int flags, void *cb_data)
593 struct tracking_name_data *cb = cb_data;
594 const char *slash;
596 if (prefixcmp(refname, "refs/remotes/"))
597 return 0;
598 slash = strchr(refname + 13, '/');
599 if (!slash || strcmp(slash + 1, cb->name))
600 return 0;
601 if (cb->remote) {
602 cb->unique = 0;
603 return 0;
605 cb->remote = xstrdup(refname);
606 return 0;
609 static const char *unique_tracking_name(const char *name)
611 struct tracking_name_data cb_data = { name, NULL, 1 };
612 for_each_ref(check_tracking_name, &cb_data);
613 if (cb_data.unique)
614 return cb_data.remote;
615 free(cb_data.remote);
616 return NULL;
619 int cmd_checkout(int argc, const char **argv, const char *prefix)
621 struct checkout_opts opts;
622 unsigned char rev[20];
623 const char *arg;
624 struct branch_info new;
625 struct tree *source_tree = NULL;
626 char *conflict_style = NULL;
627 int patch_mode = 0;
628 int dwim_new_local_branch = 1;
629 struct option options[] = {
630 OPT__QUIET(&opts.quiet),
631 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
632 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
633 OPT_SET_INT('t', "track", &opts.track, "track",
634 BRANCH_TRACK_EXPLICIT),
635 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
637 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
639 OPT_BOOLEAN('f', "force", &opts.force, "force"),
640 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
641 OPT_STRING(0, "conflict", &conflict_style, "style",
642 "conflict style (merge or diff3)"),
643 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
644 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
645 "second guess 'git checkout no-such-branch'",
646 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
647 OPT_END(),
649 int has_dash_dash;
651 memset(&opts, 0, sizeof(opts));
652 memset(&new, 0, sizeof(new));
654 git_config(git_checkout_config, NULL);
656 opts.track = BRANCH_TRACK_UNSPECIFIED;
658 argc = parse_options(argc, argv, prefix, options, checkout_usage,
659 PARSE_OPT_KEEP_DASHDASH);
661 if (patch_mode && (opts.track > 0 || opts.new_branch
662 || opts.new_branch_log || opts.merge || opts.force))
663 die ("--patch is incompatible with all other options");
665 /* --track without -b should DWIM */
666 if (0 < opts.track && !opts.new_branch) {
667 const char *argv0 = argv[0];
668 if (!argc || !strcmp(argv0, "--"))
669 die ("--track needs a branch name");
670 if (!prefixcmp(argv0, "refs/"))
671 argv0 += 5;
672 if (!prefixcmp(argv0, "remotes/"))
673 argv0 += 8;
674 argv0 = strchr(argv0, '/');
675 if (!argv0 || !argv0[1])
676 die ("Missing branch name; try -b");
677 opts.new_branch = argv0 + 1;
680 if (conflict_style) {
681 opts.merge = 1; /* implied */
682 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
685 if (opts.force && opts.merge)
686 die("git checkout: -f and -m are incompatible");
689 * case 1: git checkout <ref> -- [<paths>]
691 * <ref> must be a valid tree, everything after the '--' must be
692 * a path.
694 * case 2: git checkout -- [<paths>]
696 * everything after the '--' must be paths.
698 * case 3: git checkout <something> [<paths>]
700 * With no paths, if <something> is a commit, that is to
701 * switch to the branch or detach HEAD at it. As a special case,
702 * if <something> is A...B (missing A or B means HEAD but you can
703 * omit at most one side), and if there is a unique merge base
704 * between A and B, A...B names that merge base.
706 * With no paths, if <something> is _not_ a commit, no -t nor -b
707 * was given, and there is a tracking branch whose name is
708 * <something> in one and only one remote, then this is a short-hand
709 * to fork local <something> from that remote tracking branch.
711 * Otherwise <something> shall not be ambiguous.
712 * - If it's *only* a reference, treat it like case (1).
713 * - If it's only a path, treat it like case (2).
714 * - else: fail.
717 if (argc) {
718 if (!strcmp(argv[0], "--")) { /* case (2) */
719 argv++;
720 argc--;
721 goto no_reference;
724 arg = argv[0];
725 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
727 if (!strcmp(arg, "-"))
728 arg = "@{-1}";
730 if (get_sha1_mb(arg, rev)) {
731 if (has_dash_dash) /* case (1) */
732 die("invalid reference: %s", arg);
733 if (!patch_mode &&
734 dwim_new_local_branch &&
735 opts.track == BRANCH_TRACK_UNSPECIFIED &&
736 !opts.new_branch &&
737 !check_filename(NULL, arg) &&
738 argc == 1) {
739 const char *remote = unique_tracking_name(arg);
740 if (!remote || get_sha1(remote, rev))
741 goto no_reference;
742 opts.new_branch = arg;
743 arg = remote;
744 /* DWIMmed to create local branch */
746 else
747 goto no_reference;
750 /* we can't end up being in (2) anymore, eat the argument */
751 argv++;
752 argc--;
754 new.name = arg;
755 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
756 setup_branch_path(&new);
758 if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
759 resolve_ref(new.path, rev, 1, NULL))
761 else
762 new.path = NULL;
763 parse_commit(new.commit);
764 source_tree = new.commit->tree;
765 } else
766 source_tree = parse_tree_indirect(rev);
768 if (!source_tree) /* case (1): want a tree */
769 die("reference is not a tree: %s", arg);
770 if (!has_dash_dash) {/* case (3 -> 1) */
772 * Do not complain the most common case
773 * git checkout branch
774 * even if there happen to be a file called 'branch';
775 * it would be extremely annoying.
777 if (argc)
778 verify_non_filename(NULL, arg);
780 else {
781 argv++;
782 argc--;
786 no_reference:
788 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
789 opts.track = git_branch_track;
791 if (argc) {
792 const char **pathspec = get_pathspec(prefix, argv);
794 if (!pathspec)
795 die("invalid path specification");
797 if (patch_mode)
798 return interactive_checkout(new.name, pathspec, &opts);
800 /* Checkout paths */
801 if (opts.new_branch) {
802 if (argc == 1) {
803 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]);
804 } else {
805 die("git checkout: updating paths is incompatible with switching branches.");
809 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
810 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
812 return checkout_paths(source_tree, pathspec, &opts);
815 if (patch_mode)
816 return interactive_checkout(new.name, NULL, &opts);
818 if (opts.new_branch) {
819 struct strbuf buf = STRBUF_INIT;
820 if (strbuf_check_branch_ref(&buf, opts.new_branch))
821 die("git checkout: we do not like '%s' as a branch name.",
822 opts.new_branch);
823 if (!get_sha1(buf.buf, rev))
824 die("git checkout: branch %s already exists", opts.new_branch);
825 strbuf_release(&buf);
828 if (new.name && !new.commit) {
829 die("Cannot switch branch to a non-commit.");
831 if (opts.writeout_stage)
832 die("--ours/--theirs is incompatible with switching branches.");
834 return switch_branches(&opts, &new);