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