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