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