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