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