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