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