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