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