Change check_ref_format() to take a flags argument
[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"
0faf2474 660 "%s\n",
f06f08b7
ÆAB
661 /* The plural version */
662 "Warning: you are leaving %d commits behind, "
8e2dc6ac
JH
663 "not connected to\n"
664 "any of your branches:\n\n"
f807b3dc 665 "%s\n",
f06f08b7
ÆAB
666 /* Give ngettext() the count */
667 lost),
668 lost,
f807b3dc 669 sb.buf);
8e2dc6ac 670 strbuf_release(&sb);
f807b3dc
JH
671
672 if (advice_detached_head)
673 fprintf(stderr,
0faf2474 674 _(
f807b3dc
JH
675 "If you want to keep them by creating a new branch, "
676 "this may be a good time\nto do so with:\n\n"
0faf2474 677 " git branch new_branch_name %s\n\n"),
f807b3dc 678 sha1_to_hex(commit->object.sha1));
8e2dc6ac
JH
679}
680
681/*
682 * We are about to leave commit that was at the tip of a detached
683 * HEAD. If it is not reachable from any ref, this is the last chance
684 * for the user to do so without resorting to reflog.
685 */
686static void orphaned_commit_warning(struct commit *commit)
687{
688 struct rev_list_args args = { 0, 0, NULL };
689 struct rev_info revs;
690
691 add_one_rev_list_arg(&args, "(internal)");
692 add_one_rev_list_arg(&args, sha1_to_hex(commit->object.sha1));
693 add_one_rev_list_arg(&args, "--not");
694 for_each_ref(add_one_ref_to_rev_list_arg, &args);
695 add_one_rev_list_arg(&args, "--");
696 add_one_rev_list_arg(&args, NULL);
697
698 init_revisions(&revs, NULL);
699 if (setup_revisions(args.argc - 1, args.argv, &revs, NULL) != 1)
6c80cd29 700 die(_("internal error: only -- alone should have been left"));
8e2dc6ac 701 if (prepare_revision_walk(&revs))
6c80cd29 702 die(_("internal error in revision walk"));
8e2dc6ac
JH
703 if (!(commit->object.flags & UNINTERESTING))
704 suggest_reattach(commit, &revs);
705 else
6c80cd29 706 describe_detached_head(_("Previous HEAD position was"), commit);
5c08dc48
JK
707
708 clear_commit_marks(commit, -1);
709 for_each_ref(clear_commit_marks_from_one_ref, NULL);
8e2dc6ac
JH
710}
711
75ea38df 712static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
782c2d65
DB
713{
714 int ret = 0;
715 struct branch_info old;
716 unsigned char rev[20];
717 int flag;
718 memset(&old, 0, sizeof(old));
c5bcf1f9 719 old.path = xstrdup(resolve_ref("HEAD", rev, 0, &flag));
782c2d65 720 old.commit = lookup_commit_reference_gently(rev, 1);
c5bcf1f9
JH
721 if (!(flag & REF_ISSYMREF)) {
722 free((char *)old.path);
782c2d65 723 old.path = NULL;
c5bcf1f9 724 }
782c2d65
DB
725
726 if (old.path && !prefixcmp(old.path, "refs/heads/"))
727 old.name = old.path + strlen("refs/heads/");
728
729 if (!new->name) {
730 new->name = "HEAD";
731 new->commit = old.commit;
732 if (!new->commit)
e8a8a4d7 733 die(_("You are on a branch yet to be born"));
782c2d65
DB
734 parse_commit(new->commit);
735 }
736
75ea38df 737 ret = merge_working_tree(opts, &old, new);
782c2d65
DB
738 if (ret)
739 return ret;
740
77ebd56d 741 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
8e2dc6ac 742 orphaned_commit_warning(old.commit);
77ebd56d 743
782c2d65
DB
744 update_refs_for_switch(opts, &old, new);
745
291d823e 746 ret = post_checkout_hook(old.commit, new->commit, 1);
4d9e42f8 747 free((char *)old.path);
291d823e 748 return ret || opts->writeout_error;
782c2d65
DB
749}
750
0cf8581e
JH
751static int git_checkout_config(const char *var, const char *value, void *cb)
752{
175f6e59
JS
753 if (!strcmp(var, "diff.ignoresubmodules")) {
754 struct checkout_opts *opts = cb;
755 handle_ignore_submodules_arg(&opts->diff_options, value);
756 return 0;
757 }
23b4c7bc
JL
758
759 if (!prefixcmp(var, "submodule."))
760 return parse_submodule_config_option(var, value);
761
175f6e59 762 return git_xmerge_config(var, value, NULL);
0cf8581e
JH
763}
764
4f353658
TR
765static int interactive_checkout(const char *revision, const char **pathspec,
766 struct checkout_opts *opts)
767{
768 return run_add_interactive(revision, "--patch=checkout", pathspec);
769}
770
70c9ac2f
JH
771struct tracking_name_data {
772 const char *name;
773 char *remote;
774 int unique;
775};
776
777static int check_tracking_name(const char *refname, const unsigned char *sha1,
778 int flags, void *cb_data)
779{
780 struct tracking_name_data *cb = cb_data;
781 const char *slash;
782
783 if (prefixcmp(refname, "refs/remotes/"))
784 return 0;
785 slash = strchr(refname + 13, '/');
786 if (!slash || strcmp(slash + 1, cb->name))
787 return 0;
788 if (cb->remote) {
789 cb->unique = 0;
790 return 0;
791 }
792 cb->remote = xstrdup(refname);
793 return 0;
794}
795
796static const char *unique_tracking_name(const char *name)
797{
66dbfd55
GV
798 struct tracking_name_data cb_data = { NULL, NULL, 1 };
799 cb_data.name = name;
70c9ac2f
JH
800 for_each_ref(check_tracking_name, &cb_data);
801 if (cb_data.unique)
802 return cb_data.remote;
803 free(cb_data.remote);
804 return NULL;
805}
4f353658 806
09ebad6f
JN
807static int parse_branchname_arg(int argc, const char **argv,
808 int dwim_new_local_branch_ok,
809 struct branch_info *new,
810 struct tree **source_tree,
811 unsigned char rev[20],
812 const char **new_branch)
813{
814 int argcount = 0;
815 unsigned char branch_rev[20];
816 const char *arg;
817 int has_dash_dash;
818
819 /*
820 * case 1: git checkout <ref> -- [<paths>]
821 *
822 * <ref> must be a valid tree, everything after the '--' must be
823 * a path.
824 *
825 * case 2: git checkout -- [<paths>]
826 *
827 * everything after the '--' must be paths.
828 *
829 * case 3: git checkout <something> [<paths>]
830 *
831 * With no paths, if <something> is a commit, that is to
832 * switch to the branch or detach HEAD at it. As a special case,
833 * if <something> is A...B (missing A or B means HEAD but you can
834 * omit at most one side), and if there is a unique merge base
835 * between A and B, A...B names that merge base.
836 *
837 * With no paths, if <something> is _not_ a commit, no -t nor -b
838 * was given, and there is a tracking branch whose name is
839 * <something> in one and only one remote, then this is a short-hand
c0791f36 840 * to fork local <something> from that remote-tracking branch.
09ebad6f
JN
841 *
842 * Otherwise <something> shall not be ambiguous.
843 * - If it's *only* a reference, treat it like case (1).
844 * - If it's only a path, treat it like case (2).
845 * - else: fail.
846 *
847 */
848 if (!argc)
849 return 0;
850
851 if (!strcmp(argv[0], "--")) /* case (2) */
852 return 1;
853
854 arg = argv[0];
855 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
856
857 if (!strcmp(arg, "-"))
858 arg = "@{-1}";
859
860 if (get_sha1_mb(arg, rev)) {
861 if (has_dash_dash) /* case (1) */
6c80cd29 862 die(_("invalid reference: %s"), arg);
09ebad6f
JN
863 if (dwim_new_local_branch_ok &&
864 !check_filename(NULL, arg) &&
865 argc == 1) {
866 const char *remote = unique_tracking_name(arg);
867 if (!remote || get_sha1(remote, rev))
868 return argcount;
869 *new_branch = arg;
870 arg = remote;
871 /* DWIMmed to create local branch */
872 } else {
873 return argcount;
874 }
875 }
876
877 /* we can't end up being in (2) anymore, eat the argument */
878 argcount++;
879 argv++;
880 argc--;
881
882 new->name = arg;
883 setup_branch_path(new);
884
8d9c5010 885 if (!check_refname_format(new->path, 0) &&
09ebad6f
JN
886 resolve_ref(new->path, branch_rev, 1, NULL))
887 hashcpy(rev, branch_rev);
888 else
889 new->path = NULL; /* not an existing branch */
890
891 new->commit = lookup_commit_reference_gently(rev, 1);
892 if (!new->commit) {
893 /* not a commit */
894 *source_tree = parse_tree_indirect(rev);
895 } else {
896 parse_commit(new->commit);
897 *source_tree = new->commit->tree;
898 }
899
900 if (!*source_tree) /* case (1): want a tree */
6c80cd29 901 die(_("reference is not a tree: %s"), arg);
09ebad6f
JN
902 if (!has_dash_dash) {/* case (3 -> 1) */
903 /*
904 * Do not complain the most common case
905 * git checkout branch
906 * even if there happen to be a file called 'branch';
907 * it would be extremely annoying.
908 */
909 if (argc)
910 verify_non_filename(NULL, arg);
911 } else {
912 argcount++;
913 argv++;
914 argc--;
915 }
916
917 return argcount;
918}
919
782c2d65
DB
920int cmd_checkout(int argc, const char **argv, const char *prefix)
921{
922 struct checkout_opts opts;
923 unsigned char rev[20];
782c2d65
DB
924 struct branch_info new;
925 struct tree *source_tree = NULL;
eac5a401 926 char *conflict_style = NULL;
4f353658 927 int patch_mode = 0;
46148dd7 928 int dwim_new_local_branch = 1;
782c2d65 929 struct option options[] = {
8c839683 930 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
4c688751
TRC
931 OPT_STRING('b', NULL, &opts.new_branch, "branch",
932 "create and checkout a new branch"),
02ac9837
TRC
933 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
934 "create/reset and checkout a branch"),
3695dc0a 935 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
32669671 936 OPT_BOOLEAN(0, "detach", &opts.force_detach, "detach the HEAD at named commit"),
3695dc0a 937 OPT_SET_INT('t', "track", &opts.track, "set upstream info for new branch",
9ed36cfa 938 BRANCH_TRACK_EXPLICIT),
9db5ebf4 939 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
3695dc0a 940 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
38901a48 941 2),
3695dc0a 942 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
38901a48 943 3),
76946b76 944 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
3695dc0a 945 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
eac5a401
JH
946 OPT_STRING(0, "conflict", &conflict_style, "style",
947 "conflict style (merge or diff3)"),
4f353658 948 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
46148dd7
JH
949 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
950 "second guess 'git checkout no-such-branch'",
951 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
b249b552 952 OPT_END(),
782c2d65
DB
953 };
954
955 memset(&opts, 0, sizeof(opts));
956 memset(&new, 0, sizeof(new));
957
23b4c7bc 958 gitmodules_config();
175f6e59 959 git_config(git_checkout_config, &opts);
782c2d65 960
9188ed89 961 opts.track = BRANCH_TRACK_UNSPECIFIED;
782c2d65 962
37782920 963 argc = parse_options(argc, argv, prefix, options, checkout_usage,
f5242ebf 964 PARSE_OPT_KEEP_DASHDASH);
859fdaba 965
02ac9837
TRC
966 /* we can assume from now on new_branch = !new_branch_force */
967 if (opts.new_branch && opts.new_branch_force)
e8a8a4d7 968 die(_("-B cannot be used with -b"));
02ac9837
TRC
969
970 /* copy -B over to -b, so that we can just check the latter */
971 if (opts.new_branch_force)
972 opts.new_branch = opts.new_branch_force;
973
4f353658 974 if (patch_mode && (opts.track > 0 || opts.new_branch
32669671
JH
975 || opts.new_branch_log || opts.merge || opts.force
976 || opts.force_detach))
e8a8a4d7 977 die (_("--patch is incompatible with all other options"));
4f353658 978
32669671 979 if (opts.force_detach && (opts.new_branch || opts.new_orphan_branch))
20fc73e3 980 die(_("--detach cannot be used with -b/-B/--orphan"));
32669671 981 if (opts.force_detach && 0 < opts.track)
20fc73e3 982 die(_("--detach cannot be used with -t"));
32669671 983
bb0ceb62 984 /* --track without -b should DWIM */
9188ed89
AR
985 if (0 < opts.track && !opts.new_branch) {
986 const char *argv0 = argv[0];
987 if (!argc || !strcmp(argv0, "--"))
e8a8a4d7 988 die (_("--track needs a branch name"));
9188ed89
AR
989 if (!prefixcmp(argv0, "refs/"))
990 argv0 += 5;
991 if (!prefixcmp(argv0, "remotes/"))
992 argv0 += 8;
993 argv0 = strchr(argv0, '/');
994 if (!argv0 || !argv0[1])
e8a8a4d7 995 die (_("Missing branch name; try -b"));
9188ed89 996 opts.new_branch = argv0 + 1;
bb0ceb62
JS
997 }
998
9db5ebf4
EM
999 if (opts.new_orphan_branch) {
1000 if (opts.new_branch)
e8a8a4d7 1001 die(_("--orphan and -b|-B are mutually exclusive"));
3631bf77 1002 if (opts.track > 0)
e8a8a4d7 1003 die(_("--orphan cannot be used with -t"));
9db5ebf4
EM
1004 opts.new_branch = opts.new_orphan_branch;
1005 }
1006
eac5a401
JH
1007 if (conflict_style) {
1008 opts.merge = 1; /* implied */
1009 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
1010 }
1011
859fdaba 1012 if (opts.force && opts.merge)
e8a8a4d7 1013 die(_("git checkout: -f and -m are incompatible"));
859fdaba
PH
1014
1015 /*
09ebad6f
JN
1016 * Extract branch name from command line arguments, so
1017 * all that is left is pathspecs.
859fdaba 1018 *
09ebad6f 1019 * Handle
70c9ac2f 1020 *
09ebad6f
JN
1021 * 1) git checkout <tree> -- [<paths>]
1022 * 2) git checkout -- [<paths>]
1023 * 3) git checkout <something> [<paths>]
859fdaba 1024 *
09ebad6f
JN
1025 * including "last branch" syntax and DWIM-ery for names of
1026 * remote branches, erroring out for invalid or ambiguous cases.
859fdaba 1027 */
782c2d65 1028 if (argc) {
09ebad6f
JN
1029 int dwim_ok =
1030 !patch_mode &&
1031 dwim_new_local_branch &&
1032 opts.track == BRANCH_TRACK_UNSPECIFIED &&
1033 !opts.new_branch;
f8bd36a4 1034 int n = parse_branchname_arg(argc, argv, dwim_ok,
09ebad6f
JN
1035 &new, &source_tree, rev, &opts.new_branch);
1036 argv += n;
1037 argc -= n;
782c2d65
DB
1038 }
1039
70c9ac2f
JH
1040 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
1041 opts.track = git_branch_track;
1042
782c2d65
DB
1043 if (argc) {
1044 const char **pathspec = get_pathspec(prefix, argv);
301e42ed
AR
1045
1046 if (!pathspec)
e8a8a4d7 1047 die(_("invalid path specification"));
301e42ed 1048
4f353658
TR
1049 if (patch_mode)
1050 return interactive_checkout(new.name, pathspec, &opts);
1051
782c2d65 1052 /* Checkout paths */
0cf8581e 1053 if (opts.new_branch) {
782c2d65 1054 if (argc == 1) {
e8a8a4d7 1055 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 1056 } else {
e8a8a4d7 1057 die(_("git checkout: updating paths is incompatible with switching branches."));
782c2d65
DB
1058 }
1059 }
1060
32669671 1061 if (opts.force_detach)
20fc73e3 1062 die(_("git checkout: --detach does not take a path argument"));
32669671 1063
0cf8581e 1064 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
e8a8a4d7 1065 die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
0cf8581e 1066
0f64bfa9 1067 return checkout_paths(source_tree, pathspec, prefix, &opts);
782c2d65
DB
1068 }
1069
4f353658
TR
1070 if (patch_mode)
1071 return interactive_checkout(new.name, NULL, &opts);
1072
352eadc4 1073 if (opts.new_branch) {
f285a2d7 1074 struct strbuf buf = STRBUF_INIT;
55c4a673
CI
1075
1076 opts.branch_exists = validate_new_branchname(opts.new_branch, &buf, !!opts.new_branch_force);
1077
352eadc4
DB
1078 strbuf_release(&buf);
1079 }
1080
782c2d65 1081 if (new.name && !new.commit) {
e8a8a4d7 1082 die(_("Cannot switch branch to a non-commit."));
782c2d65 1083 }
38901a48 1084 if (opts.writeout_stage)
e8a8a4d7 1085 die(_("--ours/--theirs is incompatible with switching branches."));
782c2d65 1086
75ea38df 1087 return switch_branches(&opts, &new);
782c2d65 1088}