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