rerere: never renormalize
[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",
6d6f9acc 158 &ours, "ours", &theirs, "theirs", 0);
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);
8a2fce18
MV
440 init_merge_options(&o);
441 o.verbosity = 0;
442 work = write_tree_from_memory(&o);
782c2d65 443
6286a08d 444 ret = reset_tree(new->commit->tree, opts, 1);
782c2d65
DB
445 if (ret)
446 return ret;
c4151629 447 o.ancestor = old->name;
8a2fce18
MV
448 o.branch1 = new->name;
449 o.branch2 = "local";
450 merge_trees(&o, new->commit->tree, work,
451 old->commit->tree, &result);
6286a08d 452 ret = reset_tree(new->commit->tree, opts, 0);
84a5750b
JH
453 if (ret)
454 return ret;
782c2d65
DB
455 }
456 }
457
458 if (write_cache(newfd, active_cache, active_nr) ||
459 commit_locked_index(lock_file))
460 die("unable to write new index file");
461
7fe4a728 462 if (!opts->force && !opts->quiet)
782c2d65
DB
463 show_local_changes(&new->commit->object);
464
465 return 0;
466}
467
6d21bf96 468static void report_tracking(struct branch_info *new)
79a1e6b4 469{
6d21bf96 470 struct strbuf sb = STRBUF_INIT;
b56fca07 471 struct branch *branch = branch_get(new->name);
79a1e6b4 472
6d21bf96 473 if (!format_tracking_info(branch, &sb))
79a1e6b4 474 return;
6d21bf96
JH
475 fputs(sb.buf, stdout);
476 strbuf_release(&sb);
b0030db3 477}
79a1e6b4 478
13be3e31
JH
479static void detach_advice(const char *old_path, const char *new_name)
480{
481 const char fmt[] =
482 "Note: checking out '%s'.\n\n"
483 "You are in 'detached HEAD' state. You can look around, make experimental\n"
484 "changes and commit them, and you can discard any commits you make in this\n"
485 "state without impacting any branches by performing another checkout.\n\n"
486 "If you want to create a new branch to retain commits you create, you may\n"
487 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
488 " git checkout -b new_branch_name\n\n";
489
490 fprintf(stderr, fmt, new_name);
491}
492
782c2d65
DB
493static void update_refs_for_switch(struct checkout_opts *opts,
494 struct branch_info *old,
495 struct branch_info *new)
496{
f285a2d7 497 struct strbuf msg = STRBUF_INIT;
782c2d65
DB
498 const char *old_desc;
499 if (opts->new_branch) {
3631bf77
EM
500 if (opts->new_orphan_branch) {
501 if (opts->new_branch_log && !log_all_ref_updates) {
502 int temp;
157aaea5 503 char log_file[PATH_MAX];
3631bf77
EM
504 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
505
506 temp = log_all_ref_updates;
507 log_all_ref_updates = 1;
157aaea5 508 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
3631bf77
EM
509 fprintf(stderr, "Can not do reflog for '%s'\n",
510 opts->new_orphan_branch);
511 log_all_ref_updates = temp;
512 return;
513 }
514 log_all_ref_updates = temp;
515 }
516 }
517 else
9db5ebf4
EM
518 create_branch(old->name, opts->new_branch, new->name, 0,
519 opts->new_branch_log, opts->track);
782c2d65
DB
520 new->name = opts->new_branch;
521 setup_branch_path(new);
522 }
523
782c2d65 524 old_desc = old->name;
323e00fd 525 if (!old_desc && old->commit)
782c2d65
DB
526 old_desc = sha1_to_hex(old->commit->object.sha1);
527 strbuf_addf(&msg, "checkout: moving from %s to %s",
323e00fd 528 old_desc ? old_desc : "(invalid)", new->name);
782c2d65
DB
529
530 if (new->path) {
531 create_symref("HEAD", new->path, msg.buf);
532 if (!opts->quiet) {
533 if (old->path && !strcmp(new->path, old->path))
714fddf2 534 fprintf(stderr, "Already on '%s'\n",
782c2d65
DB
535 new->name);
536 else
714fddf2 537 fprintf(stderr, "Switched to%s branch '%s'\n",
782c2d65
DB
538 opts->new_branch ? " a new" : "",
539 new->name);
540 }
3631bf77
EM
541 if (old->path && old->name) {
542 char log_file[PATH_MAX], ref_file[PATH_MAX];
543
544 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
545 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
546 if (!file_exists(ref_file) && file_exists(log_file))
547 remove_path(log_file);
548 }
782c2d65
DB
549 } else if (strcmp(new->name, "HEAD")) {
550 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
551 REF_NODEREF, DIE_ON_ERR);
552 if (!opts->quiet) {
13be3e31
JH
553 if (old->path && advice_detached_head)
554 detach_advice(old->path, new->name);
782c2d65
DB
555 describe_detached_head("HEAD is now at", new->commit);
556 }
557 }
558 remove_branch_state();
559 strbuf_release(&msg);
b0030db3 560 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
6d21bf96 561 report_tracking(new);
782c2d65
DB
562}
563
75ea38df 564static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
782c2d65
DB
565{
566 int ret = 0;
567 struct branch_info old;
568 unsigned char rev[20];
569 int flag;
570 memset(&old, 0, sizeof(old));
571 old.path = resolve_ref("HEAD", rev, 0, &flag);
572 old.commit = lookup_commit_reference_gently(rev, 1);
573 if (!(flag & REF_ISSYMREF))
574 old.path = NULL;
575
576 if (old.path && !prefixcmp(old.path, "refs/heads/"))
577 old.name = old.path + strlen("refs/heads/");
578
579 if (!new->name) {
580 new->name = "HEAD";
581 new->commit = old.commit;
582 if (!new->commit)
583 die("You are on a branch yet to be born");
584 parse_commit(new->commit);
585 }
586
75ea38df 587 ret = merge_working_tree(opts, &old, new);
782c2d65
DB
588 if (ret)
589 return ret;
590
77ebd56d
DC
591 /*
592 * If we were on a detached HEAD, but have now moved to
593 * a new commit, we want to mention the old commit once more
594 * to remind the user that it might be lost.
595 */
596 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
597 describe_detached_head("Previous HEAD position was", old.commit);
598
782c2d65
DB
599 update_refs_for_switch(opts, &old, new);
600
291d823e
JH
601 ret = post_checkout_hook(old.commit, new->commit, 1);
602 return ret || opts->writeout_error;
782c2d65
DB
603}
604
0cf8581e
JH
605static int git_checkout_config(const char *var, const char *value, void *cb)
606{
607 return git_xmerge_config(var, value, cb);
608}
609
4f353658
TR
610static int interactive_checkout(const char *revision, const char **pathspec,
611 struct checkout_opts *opts)
612{
613 return run_add_interactive(revision, "--patch=checkout", pathspec);
614}
615
70c9ac2f
JH
616struct tracking_name_data {
617 const char *name;
618 char *remote;
619 int unique;
620};
621
622static int check_tracking_name(const char *refname, const unsigned char *sha1,
623 int flags, void *cb_data)
624{
625 struct tracking_name_data *cb = cb_data;
626 const char *slash;
627
628 if (prefixcmp(refname, "refs/remotes/"))
629 return 0;
630 slash = strchr(refname + 13, '/');
631 if (!slash || strcmp(slash + 1, cb->name))
632 return 0;
633 if (cb->remote) {
634 cb->unique = 0;
635 return 0;
636 }
637 cb->remote = xstrdup(refname);
638 return 0;
639}
640
641static const char *unique_tracking_name(const char *name)
642{
66dbfd55
GV
643 struct tracking_name_data cb_data = { NULL, NULL, 1 };
644 cb_data.name = name;
70c9ac2f
JH
645 for_each_ref(check_tracking_name, &cb_data);
646 if (cb_data.unique)
647 return cb_data.remote;
648 free(cb_data.remote);
649 return NULL;
650}
4f353658 651
782c2d65
DB
652int cmd_checkout(int argc, const char **argv, const char *prefix)
653{
654 struct checkout_opts opts;
655 unsigned char rev[20];
656 const char *arg;
657 struct branch_info new;
658 struct tree *source_tree = NULL;
eac5a401 659 char *conflict_style = NULL;
4f353658 660 int patch_mode = 0;
46148dd7 661 int dwim_new_local_branch = 1;
782c2d65
DB
662 struct option options[] = {
663 OPT__QUIET(&opts.quiet),
664 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
665 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
498a6e7e 666 OPT_SET_INT('t', "track", &opts.track, "track",
9ed36cfa 667 BRANCH_TRACK_EXPLICIT),
9db5ebf4 668 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
38901a48
JH
669 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
670 2),
671 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
672 3),
f7aec129 673 OPT_BOOLEAN('f', "force", &opts.force, "force"),
eac5a401
JH
674 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
675 OPT_STRING(0, "conflict", &conflict_style, "style",
676 "conflict style (merge or diff3)"),
4f353658 677 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
46148dd7
JH
678 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
679 "second guess 'git checkout no-such-branch'",
680 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
b249b552 681 OPT_END(),
782c2d65 682 };
859fdaba 683 int has_dash_dash;
782c2d65
DB
684
685 memset(&opts, 0, sizeof(opts));
686 memset(&new, 0, sizeof(new));
687
0cf8581e 688 git_config(git_checkout_config, NULL);
782c2d65 689
9188ed89 690 opts.track = BRANCH_TRACK_UNSPECIFIED;
782c2d65 691
37782920 692 argc = parse_options(argc, argv, prefix, options, checkout_usage,
f5242ebf 693 PARSE_OPT_KEEP_DASHDASH);
859fdaba 694
4f353658
TR
695 if (patch_mode && (opts.track > 0 || opts.new_branch
696 || opts.new_branch_log || opts.merge || opts.force))
697 die ("--patch is incompatible with all other options");
698
bb0ceb62 699 /* --track without -b should DWIM */
9188ed89
AR
700 if (0 < opts.track && !opts.new_branch) {
701 const char *argv0 = argv[0];
702 if (!argc || !strcmp(argv0, "--"))
bb0ceb62 703 die ("--track needs a branch name");
9188ed89
AR
704 if (!prefixcmp(argv0, "refs/"))
705 argv0 += 5;
706 if (!prefixcmp(argv0, "remotes/"))
707 argv0 += 8;
708 argv0 = strchr(argv0, '/');
709 if (!argv0 || !argv0[1])
bb0ceb62 710 die ("Missing branch name; try -b");
9188ed89 711 opts.new_branch = argv0 + 1;
bb0ceb62
JS
712 }
713
9db5ebf4
EM
714 if (opts.new_orphan_branch) {
715 if (opts.new_branch)
716 die("--orphan and -b are mutually exclusive");
3631bf77
EM
717 if (opts.track > 0)
718 die("--orphan cannot be used with -t");
9db5ebf4
EM
719 opts.new_branch = opts.new_orphan_branch;
720 }
721
eac5a401
JH
722 if (conflict_style) {
723 opts.merge = 1; /* implied */
724 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
725 }
726
859fdaba
PH
727 if (opts.force && opts.merge)
728 die("git checkout: -f and -m are incompatible");
729
730 /*
731 * case 1: git checkout <ref> -- [<paths>]
732 *
733 * <ref> must be a valid tree, everything after the '--' must be
734 * a path.
735 *
736 * case 2: git checkout -- [<paths>]
737 *
738 * everything after the '--' must be paths.
739 *
740 * case 3: git checkout <something> [<paths>]
741 *
742 * With no paths, if <something> is a commit, that is to
619a644d
JH
743 * switch to the branch or detach HEAD at it. As a special case,
744 * if <something> is A...B (missing A or B means HEAD but you can
745 * omit at most one side), and if there is a unique merge base
746 * between A and B, A...B names that merge base.
859fdaba 747 *
70c9ac2f
JH
748 * With no paths, if <something> is _not_ a commit, no -t nor -b
749 * was given, and there is a tracking branch whose name is
750 * <something> in one and only one remote, then this is a short-hand
751 * to fork local <something> from that remote tracking branch.
752 *
859fdaba
PH
753 * Otherwise <something> shall not be ambiguous.
754 * - If it's *only* a reference, treat it like case (1).
755 * - If it's only a path, treat it like case (2).
756 * - else: fail.
757 *
758 */
782c2d65 759 if (argc) {
859fdaba
PH
760 if (!strcmp(argv[0], "--")) { /* case (2) */
761 argv++;
762 argc--;
763 goto no_reference;
764 }
765
782c2d65 766 arg = argv[0];
859fdaba
PH
767 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
768
696acf45
TR
769 if (!strcmp(arg, "-"))
770 arg = "@{-1}";
771
619a644d 772 if (get_sha1_mb(arg, rev)) {
859fdaba
PH
773 if (has_dash_dash) /* case (1) */
774 die("invalid reference: %s", arg);
70c9ac2f 775 if (!patch_mode &&
46148dd7 776 dwim_new_local_branch &&
70c9ac2f
JH
777 opts.track == BRANCH_TRACK_UNSPECIFIED &&
778 !opts.new_branch &&
779 !check_filename(NULL, arg) &&
780 argc == 1) {
781 const char *remote = unique_tracking_name(arg);
782 if (!remote || get_sha1(remote, rev))
783 goto no_reference;
784 opts.new_branch = arg;
785 arg = remote;
786 /* DWIMmed to create local branch */
787 }
788 else
789 goto no_reference;
859fdaba
PH
790 }
791
792 /* we can't end up being in (2) anymore, eat the argument */
793 argv++;
794 argc--;
795
3442ea4a 796 new.name = arg;
859fdaba 797 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
782c2d65 798 setup_branch_path(&new);
72a144e2
JH
799
800 if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
801 resolve_ref(new.path, rev, 1, NULL))
802 ;
782c2d65
DB
803 else
804 new.path = NULL;
805 parse_commit(new.commit);
806 source_tree = new.commit->tree;
859fdaba
PH
807 } else
808 source_tree = parse_tree_indirect(rev);
809
810 if (!source_tree) /* case (1): want a tree */
811 die("reference is not a tree: %s", arg);
812 if (!has_dash_dash) {/* case (3 -> 1) */
813 /*
814 * Do not complain the most common case
815 * git checkout branch
816 * even if there happen to be a file called 'branch';
817 * it would be extremely annoying.
818 */
819 if (argc)
820 verify_non_filename(NULL, arg);
821 }
822 else {
782c2d65
DB
823 argv++;
824 argc--;
825 }
826 }
827
859fdaba 828no_reference:
70c9ac2f
JH
829
830 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
831 opts.track = git_branch_track;
832
782c2d65
DB
833 if (argc) {
834 const char **pathspec = get_pathspec(prefix, argv);
301e42ed
AR
835
836 if (!pathspec)
837 die("invalid path specification");
838
4f353658
TR
839 if (patch_mode)
840 return interactive_checkout(new.name, pathspec, &opts);
841
782c2d65 842 /* Checkout paths */
0cf8581e 843 if (opts.new_branch) {
782c2d65 844 if (argc == 1) {
db941099 845 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 846 } else {
db941099 847 die("git checkout: updating paths is incompatible with switching branches.");
782c2d65
DB
848 }
849 }
850
0cf8581e
JH
851 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
852 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
853
db941099 854 return checkout_paths(source_tree, pathspec, &opts);
782c2d65
DB
855 }
856
4f353658
TR
857 if (patch_mode)
858 return interactive_checkout(new.name, NULL, &opts);
859
352eadc4 860 if (opts.new_branch) {
f285a2d7 861 struct strbuf buf = STRBUF_INIT;
a2fab531
JH
862 if (strbuf_check_branch_ref(&buf, opts.new_branch))
863 die("git checkout: we do not like '%s' as a branch name.",
864 opts.new_branch);
352eadc4
DB
865 if (!get_sha1(buf.buf, rev))
866 die("git checkout: branch %s already exists", opts.new_branch);
352eadc4
DB
867 strbuf_release(&buf);
868 }
869
782c2d65
DB
870 if (new.name && !new.commit) {
871 die("Cannot switch branch to a non-commit.");
872 }
38901a48
JH
873 if (opts.writeout_stage)
874 die("--ours/--theirs is incompatible with switching branches.");
782c2d65 875
75ea38df 876 return switch_branches(&opts, &new);
782c2d65 877}