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