Merge branch 'jk/argv-array' into maint
[git/git.git] / builtin / checkout.c
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"
8 #include "cache-tree.h"
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"
16 #include "remote.h"
17 #include "blob.h"
18 #include "xdiff-interface.h"
19 #include "ll-merge.h"
20 #include "resolve-undo.h"
21 #include "submodule.h"
22 #include "argv-array.h"
23
24 static const char * const checkout_usage[] = {
25 "git checkout [options] <branch>",
26 "git checkout [options] [<branch>] -- <file>...",
27 NULL,
28 };
29
30 struct checkout_opts {
31 int quiet;
32 int merge;
33 int force;
34 int force_detach;
35 int writeout_stage;
36 int writeout_error;
37
38 /* not set by parse_options */
39 int branch_exists;
40
41 const char *new_branch;
42 const char *new_branch_force;
43 const char *new_orphan_branch;
44 int new_branch_log;
45 enum branch_track track;
46 struct diff_options diff_options;
47 };
48
49 static int post_checkout_hook(struct commit *old, struct commit *new,
50 int changed)
51 {
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);
56 /* "new" can be NULL when checking out from the index before
57 a commit exists. */
58
59 }
60
61 static int update_some(const unsigned char *sha1, const char *base, int baselen,
62 const char *pathname, unsigned mode, int stage, void *context)
63 {
64 int len;
65 struct cache_entry *ce;
66
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);
75 ce->ce_flags = create_ce_flags(len, 0) | CE_UPDATE;
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
81 static int read_tree_some(struct tree *tree, const char **pathspec)
82 {
83 struct pathspec ps;
84 init_pathspec(&ps, pathspec);
85 read_tree_recursive(tree, "", 0, 0, &ps, update_some, NULL);
86 free_pathspec(&ps);
87
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
95 static 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
103 static 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 }
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);
115 }
116
117 static 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)
125 return error(_("path '%s' does not have all three versions"),
126 ce->name);
127 return 0;
128 }
129
130 static 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 }
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);
143 }
144
145 static 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)
160 return error(_("path '%s' does not have all 3 versions"), path);
161
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);
165
166 /*
167 * NEEDSWORK: re-create conflicts from merges with
168 * merge.renormalize set, too
169 */
170 status = ll_merge(&result_buf, path, &ancestor, "base",
171 &ours, "ours", &theirs, "theirs", NULL);
172 free(ancestor.ptr);
173 free(ours.ptr);
174 free(theirs.ptr);
175 if (status < 0 || !result_buf.ptr) {
176 free(result_buf.ptr);
177 return error(_("path '%s': cannot merge"), path);
178 }
179
180 /*
181 * NEEDSWORK:
182 * There is absolutely no reason to write this as a blob object
183 * and create a phony cache entry just to leak. This hack is
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))
194 die(_("Unable to add merge result for '%s'"), path);
195 ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
196 sha1,
197 path, 2, 0);
198 if (!ce)
199 die(_("make_cache_entry failed for path '%s'"), path);
200 status = checkout_entry(ce, state, NULL);
201 return status;
202 }
203
204 static int checkout_paths(struct tree *source_tree, const char **pathspec,
205 const char *prefix, struct checkout_opts *opts)
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;
213 int errs = 0;
214 int stage = opts->writeout_stage;
215 int merge = opts->merge;
216 int newfd;
217 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
218
219 newfd = hold_locked_index(lock_file, 1);
220 if (read_cache_preload(pathspec) < 0)
221 return error(_("corrupt index file"));
222
223 if (source_tree)
224 read_tree_some(source_tree, pathspec);
225
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];
232 if (source_tree && !(ce->ce_flags & CE_UPDATE))
233 continue;
234 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
235 }
236
237 if (report_path_error(ps_matched, pathspec, prefix))
238 return 1;
239
240 /* "checkout -m path" to recreate conflicted state */
241 if (opts->merge)
242 unmerge_cache(pathspec);
243
244 /* Any unmerged paths? */
245 for (pos = 0; pos < active_nr; pos++) {
246 struct cache_entry *ce = active_cache[pos];
247 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
248 if (!ce_stage(ce))
249 continue;
250 if (opts->force) {
251 warning(_("path '%s' is unmerged"), ce->name);
252 } else if (stage) {
253 errs |= check_stage(stage, ce, pos);
254 } else if (opts->merge) {
255 errs |= check_all_stages(ce, pos);
256 } else {
257 errs = 1;
258 error(_("path '%s' is unmerged"), ce->name);
259 }
260 pos = skip_same_name(ce, pos) - 1;
261 }
262 }
263 if (errs)
264 return 1;
265
266 /* Now we are committed to check them out */
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];
272 if (source_tree && !(ce->ce_flags & CE_UPDATE))
273 continue;
274 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
275 if (!ce_stage(ce)) {
276 errs |= checkout_entry(ce, &state, NULL);
277 continue;
278 }
279 if (stage)
280 errs |= checkout_stage(stage, ce, pos, &state);
281 else if (merge)
282 errs |= checkout_merged(pos, &state);
283 pos = skip_same_name(ce, pos) - 1;
284 }
285 }
286
287 if (write_cache(newfd, active_cache, active_nr) ||
288 commit_locked_index(lock_file))
289 die(_("unable to write new index file"));
290
291 resolve_ref("HEAD", rev, 0, &flag);
292 head = lookup_commit_reference_gently(rev, 1);
293
294 errs |= post_checkout_hook(head, head, 0);
295 return errs;
296 }
297
298 static void show_local_changes(struct object *head, struct diff_options *opts)
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);
303 rev.diffopt.flags = opts->flags;
304 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
305 if (diff_setup_done(&rev.diffopt) < 0)
306 die(_("diff_setup_done failed"));
307 add_pending_object(&rev, head, NULL);
308 run_diff_index(&rev, 0);
309 }
310
311 static void describe_detached_head(const char *msg, struct commit *commit)
312 {
313 struct strbuf sb = STRBUF_INIT;
314 parse_commit(commit);
315 pp_commit_easy(CMIT_FMT_ONELINE, commit, &sb);
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
321 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
322 {
323 struct unpack_trees_options opts;
324 struct tree_desc tree_desc;
325
326 memset(&opts, 0, sizeof(opts));
327 opts.head_idx = -1;
328 opts.update = worktree;
329 opts.skip_unmerged = !worktree;
330 opts.reset = 1;
331 opts.merge = 1;
332 opts.fn = oneway_merge;
333 opts.verbose_update = !o->quiet;
334 opts.src_index = &the_index;
335 opts.dst_index = &the_index;
336 parse_tree(tree);
337 init_tree_desc(&tree_desc, tree->buffer, tree->size);
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:
350 return 128;
351 }
352 }
353
354 struct 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
360 static void setup_branch_path(struct branch_info *branch)
361 {
362 struct strbuf buf = STRBUF_INIT;
363
364 strbuf_branchname(&buf, branch->name);
365 if (strcmp(buf.buf, branch->name))
366 branch->name = xstrdup(buf.buf);
367 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
368 branch->path = strbuf_detach(&buf, NULL);
369 }
370
371 static int merge_working_tree(struct checkout_opts *opts,
372 struct branch_info *old, struct branch_info *new)
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);
377
378 if (read_cache_preload(NULL) < 0)
379 return error(_("corrupt index file"));
380
381 resolve_undo_clear();
382 if (opts->force) {
383 ret = reset_tree(new->commit->tree, opts, 1);
384 if (ret)
385 return ret;
386 } else {
387 struct tree_desc trees[2];
388 struct tree *tree;
389 struct unpack_trees_options topts;
390
391 memset(&topts, 0, sizeof(topts));
392 topts.head_idx = -1;
393 topts.src_index = &the_index;
394 topts.dst_index = &the_index;
395
396 setup_unpack_trees_porcelain(&topts, "checkout");
397
398 refresh_cache(REFRESH_QUIET);
399
400 if (unmerged_cache()) {
401 error(_("you need to resolve your current index first"));
402 return 1;
403 }
404
405 /* 2-way merge to the new branch */
406 topts.initial_checkout = is_cache_unborn();
407 topts.update = 1;
408 topts.merge = 1;
409 topts.gently = opts->merge && old->commit;
410 topts.verbose_update = !opts->quiet;
411 topts.fn = twoway_merge;
412 topts.dir = xcalloc(1, sizeof(*topts.dir));
413 topts.dir->flags |= DIR_SHOW_IGNORED;
414 topts.dir->exclude_per_dir = ".gitignore";
415 tree = parse_tree_indirect(old->commit ?
416 old->commit->object.sha1 :
417 EMPTY_TREE_SHA1_BIN);
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
422 ret = unpack_trees(2, trees, &topts);
423 if (ret == -1) {
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;
431 struct merge_options o;
432 if (!opts->merge)
433 return 1;
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;
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
455 add_files_to_cache(NULL, NULL, 0);
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 */
463 init_merge_options(&o);
464 o.verbosity = 0;
465 work = write_tree_from_memory(&o);
466
467 ret = reset_tree(new->commit->tree, opts, 1);
468 if (ret)
469 return ret;
470 o.ancestor = old->name;
471 o.branch1 = new->name;
472 o.branch2 = "local";
473 merge_trees(&o, new->commit->tree, work,
474 old->commit->tree, &result);
475 ret = reset_tree(new->commit->tree, opts, 0);
476 if (ret)
477 return ret;
478 }
479 }
480
481 if (write_cache(newfd, active_cache, active_nr) ||
482 commit_locked_index(lock_file))
483 die(_("unable to write new index file"));
484
485 if (!opts->force && !opts->quiet)
486 show_local_changes(&new->commit->object, &opts->diff_options);
487
488 return 0;
489 }
490
491 static void report_tracking(struct branch_info *new)
492 {
493 struct strbuf sb = STRBUF_INIT;
494 struct branch *branch = branch_get(new->name);
495
496 if (!format_tracking_info(branch, &sb))
497 return;
498 fputs(sb.buf, stdout);
499 strbuf_release(&sb);
500 }
501
502 static 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
516 static void update_refs_for_switch(struct checkout_opts *opts,
517 struct branch_info *old,
518 struct branch_info *new)
519 {
520 struct strbuf msg = STRBUF_INIT;
521 const char *old_desc;
522 if (opts->new_branch) {
523 if (opts->new_orphan_branch) {
524 if (opts->new_branch_log && !log_all_ref_updates) {
525 int temp;
526 char log_file[PATH_MAX];
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;
531 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
532 fprintf(stderr, _("Can not do reflog for '%s'\n"),
533 opts->new_orphan_branch);
534 log_all_ref_updates = temp;
535 return;
536 }
537 log_all_ref_updates = temp;
538 }
539 }
540 else
541 create_branch(old->name, opts->new_branch, new->name,
542 opts->new_branch_force ? 1 : 0,
543 opts->new_branch_log, opts->track);
544 new->name = opts->new_branch;
545 setup_branch_path(new);
546 }
547
548 old_desc = old->name;
549 if (!old_desc && old->commit)
550 old_desc = sha1_to_hex(old->commit->object.sha1);
551 strbuf_addf(&msg, "checkout: moving from %s to %s",
552 old_desc ? old_desc : "(invalid)", new->name);
553
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);
562 describe_detached_head(_("HEAD is now at"), new->commit);
563 }
564 } else if (new->path) { /* Switch branches. */
565 create_symref("HEAD", new->path, msg.buf);
566 if (!opts->quiet) {
567 if (old->path && !strcmp(new->path, old->path)) {
568 fprintf(stderr, _("Already on '%s'\n"),
569 new->name);
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 {
576 fprintf(stderr, _("Switched to branch '%s'\n"),
577 new->name);
578 }
579 }
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 }
588 }
589 remove_branch_state();
590 strbuf_release(&msg);
591 if (!opts->quiet &&
592 (new->path || (!opts->force_detach && !strcmp(new->name, "HEAD"))))
593 report_tracking(new);
594 }
595
596 static int add_one_ref_to_rev_list_arg(const char *refname,
597 const unsigned char *sha1,
598 int flags,
599 void *cb_data)
600 {
601 argv_array_push(cb_data, refname);
602 return 0;
603 }
604
605 static int clear_commit_marks_from_one_ref(const char *refname,
606 const unsigned char *sha1,
607 int flags,
608 void *cb_data)
609 {
610 struct commit *commit = lookup_commit_reference_gently(sha1, 1);
611 if (commit)
612 clear_commit_marks(commit, -1);
613 return 0;
614 }
615
616 static void describe_one_orphan(struct strbuf *sb, struct commit *commit)
617 {
618 parse_commit(commit);
619 strbuf_addstr(sb, " ");
620 strbuf_addstr(sb,
621 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
622 strbuf_addch(sb, ' ');
623 pp_commit_easy(CMIT_FMT_ONELINE, commit, sb);
624 strbuf_addch(sb, '\n');
625 }
626
627 #define ORPHAN_CUTOFF 4
628 static void suggest_reattach(struct commit *commit, struct rev_info *revs)
629 {
630 struct commit *c, *last = NULL;
631 struct strbuf sb = STRBUF_INIT;
632 int lost = 0;
633 while ((c = get_revision(revs)) != NULL) {
634 if (lost < ORPHAN_CUTOFF)
635 describe_one_orphan(&sb, c);
636 last = c;
637 lost++;
638 }
639 if (ORPHAN_CUTOFF < lost) {
640 int more = lost - ORPHAN_CUTOFF;
641 if (more == 1)
642 describe_one_orphan(&sb, last);
643 else
644 strbuf_addf(&sb, _(" ... and %d more.\n"), more);
645 }
646
647 fprintf(stderr,
648 Q_(
649 /* The singular version */
650 "Warning: you are leaving %d commit behind, "
651 "not connected to\n"
652 "any of your branches:\n\n"
653 "%s\n",
654 /* The plural version */
655 "Warning: you are leaving %d commits behind, "
656 "not connected to\n"
657 "any of your branches:\n\n"
658 "%s\n",
659 /* Give ngettext() the count */
660 lost),
661 lost,
662 sb.buf);
663 strbuf_release(&sb);
664
665 if (advice_detached_head)
666 fprintf(stderr,
667 _(
668 "If you want to keep them by creating a new branch, "
669 "this may be a good time\nto do so with:\n\n"
670 " git branch new_branch_name %s\n\n"),
671 sha1_to_hex(commit->object.sha1));
672 }
673
674 /*
675 * We are about to leave commit that was at the tip of a detached
676 * HEAD. If it is not reachable from any ref, this is the last chance
677 * for the user to do so without resorting to reflog.
678 */
679 static void orphaned_commit_warning(struct commit *commit)
680 {
681 struct argv_array args = ARGV_ARRAY_INIT;
682 struct rev_info revs;
683
684 argv_array_push(&args, "(internal)");
685 argv_array_push(&args, sha1_to_hex(commit->object.sha1));
686 argv_array_push(&args, "--not");
687 for_each_ref(add_one_ref_to_rev_list_arg, &args);
688 argv_array_push(&args, "--");
689
690 init_revisions(&revs, NULL);
691 if (setup_revisions(args.argc - 1, args.argv, &revs, NULL) != 1)
692 die(_("internal error: only -- alone should have been left"));
693 if (prepare_revision_walk(&revs))
694 die(_("internal error in revision walk"));
695 if (!(commit->object.flags & UNINTERESTING))
696 suggest_reattach(commit, &revs);
697 else
698 describe_detached_head(_("Previous HEAD position was"), commit);
699
700 argv_array_clear(&args);
701 clear_commit_marks(commit, -1);
702 for_each_ref(clear_commit_marks_from_one_ref, NULL);
703 }
704
705 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
706 {
707 int ret = 0;
708 struct branch_info old;
709 unsigned char rev[20];
710 int flag;
711 memset(&old, 0, sizeof(old));
712 old.path = xstrdup(resolve_ref("HEAD", rev, 0, &flag));
713 old.commit = lookup_commit_reference_gently(rev, 1);
714 if (!(flag & REF_ISSYMREF)) {
715 free((char *)old.path);
716 old.path = NULL;
717 }
718
719 if (old.path && !prefixcmp(old.path, "refs/heads/"))
720 old.name = old.path + strlen("refs/heads/");
721
722 if (!new->name) {
723 new->name = "HEAD";
724 new->commit = old.commit;
725 if (!new->commit)
726 die(_("You are on a branch yet to be born"));
727 parse_commit(new->commit);
728 }
729
730 ret = merge_working_tree(opts, &old, new);
731 if (ret)
732 return ret;
733
734 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
735 orphaned_commit_warning(old.commit);
736
737 update_refs_for_switch(opts, &old, new);
738
739 ret = post_checkout_hook(old.commit, new->commit, 1);
740 free((char *)old.path);
741 return ret || opts->writeout_error;
742 }
743
744 static int git_checkout_config(const char *var, const char *value, void *cb)
745 {
746 if (!strcmp(var, "diff.ignoresubmodules")) {
747 struct checkout_opts *opts = cb;
748 handle_ignore_submodules_arg(&opts->diff_options, value);
749 return 0;
750 }
751
752 if (!prefixcmp(var, "submodule."))
753 return parse_submodule_config_option(var, value);
754
755 return git_xmerge_config(var, value, NULL);
756 }
757
758 static int interactive_checkout(const char *revision, const char **pathspec,
759 struct checkout_opts *opts)
760 {
761 return run_add_interactive(revision, "--patch=checkout", pathspec);
762 }
763
764 struct tracking_name_data {
765 const char *name;
766 char *remote;
767 int unique;
768 };
769
770 static int check_tracking_name(const char *refname, const unsigned char *sha1,
771 int flags, void *cb_data)
772 {
773 struct tracking_name_data *cb = cb_data;
774 const char *slash;
775
776 if (prefixcmp(refname, "refs/remotes/"))
777 return 0;
778 slash = strchr(refname + 13, '/');
779 if (!slash || strcmp(slash + 1, cb->name))
780 return 0;
781 if (cb->remote) {
782 cb->unique = 0;
783 return 0;
784 }
785 cb->remote = xstrdup(refname);
786 return 0;
787 }
788
789 static const char *unique_tracking_name(const char *name)
790 {
791 struct tracking_name_data cb_data = { NULL, NULL, 1 };
792 cb_data.name = name;
793 for_each_ref(check_tracking_name, &cb_data);
794 if (cb_data.unique)
795 return cb_data.remote;
796 free(cb_data.remote);
797 return NULL;
798 }
799
800 static int parse_branchname_arg(int argc, const char **argv,
801 int dwim_new_local_branch_ok,
802 struct branch_info *new,
803 struct tree **source_tree,
804 unsigned char rev[20],
805 const char **new_branch)
806 {
807 int argcount = 0;
808 unsigned char branch_rev[20];
809 const char *arg;
810 int has_dash_dash;
811
812 /*
813 * case 1: git checkout <ref> -- [<paths>]
814 *
815 * <ref> must be a valid tree, everything after the '--' must be
816 * a path.
817 *
818 * case 2: git checkout -- [<paths>]
819 *
820 * everything after the '--' must be paths.
821 *
822 * case 3: git checkout <something> [<paths>]
823 *
824 * With no paths, if <something> is a commit, that is to
825 * switch to the branch or detach HEAD at it. As a special case,
826 * if <something> is A...B (missing A or B means HEAD but you can
827 * omit at most one side), and if there is a unique merge base
828 * between A and B, A...B names that merge base.
829 *
830 * With no paths, if <something> is _not_ a commit, no -t nor -b
831 * was given, and there is a tracking branch whose name is
832 * <something> in one and only one remote, then this is a short-hand
833 * to fork local <something> from that remote-tracking branch.
834 *
835 * Otherwise <something> shall not be ambiguous.
836 * - If it's *only* a reference, treat it like case (1).
837 * - If it's only a path, treat it like case (2).
838 * - else: fail.
839 *
840 */
841 if (!argc)
842 return 0;
843
844 if (!strcmp(argv[0], "--")) /* case (2) */
845 return 1;
846
847 arg = argv[0];
848 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
849
850 if (!strcmp(arg, "-"))
851 arg = "@{-1}";
852
853 if (get_sha1_mb(arg, rev)) {
854 if (has_dash_dash) /* case (1) */
855 die(_("invalid reference: %s"), arg);
856 if (dwim_new_local_branch_ok &&
857 !check_filename(NULL, arg) &&
858 argc == 1) {
859 const char *remote = unique_tracking_name(arg);
860 if (!remote || get_sha1(remote, rev))
861 return argcount;
862 *new_branch = arg;
863 arg = remote;
864 /* DWIMmed to create local branch */
865 } else {
866 return argcount;
867 }
868 }
869
870 /* we can't end up being in (2) anymore, eat the argument */
871 argcount++;
872 argv++;
873 argc--;
874
875 new->name = arg;
876 setup_branch_path(new);
877
878 if (check_ref_format(new->path) == CHECK_REF_FORMAT_OK &&
879 resolve_ref(new->path, branch_rev, 1, NULL))
880 hashcpy(rev, branch_rev);
881 else
882 new->path = NULL; /* not an existing branch */
883
884 new->commit = lookup_commit_reference_gently(rev, 1);
885 if (!new->commit) {
886 /* not a commit */
887 *source_tree = parse_tree_indirect(rev);
888 } else {
889 parse_commit(new->commit);
890 *source_tree = new->commit->tree;
891 }
892
893 if (!*source_tree) /* case (1): want a tree */
894 die(_("reference is not a tree: %s"), arg);
895 if (!has_dash_dash) {/* case (3 -> 1) */
896 /*
897 * Do not complain the most common case
898 * git checkout branch
899 * even if there happen to be a file called 'branch';
900 * it would be extremely annoying.
901 */
902 if (argc)
903 verify_non_filename(NULL, arg);
904 } else {
905 argcount++;
906 argv++;
907 argc--;
908 }
909
910 return argcount;
911 }
912
913 int cmd_checkout(int argc, const char **argv, const char *prefix)
914 {
915 struct checkout_opts opts;
916 unsigned char rev[20];
917 struct branch_info new;
918 struct tree *source_tree = NULL;
919 char *conflict_style = NULL;
920 int patch_mode = 0;
921 int dwim_new_local_branch = 1;
922 struct option options[] = {
923 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
924 OPT_STRING('b', NULL, &opts.new_branch, "branch",
925 "create and checkout a new branch"),
926 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
927 "create/reset and checkout a branch"),
928 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
929 OPT_BOOLEAN(0, "detach", &opts.force_detach, "detach the HEAD at named commit"),
930 OPT_SET_INT('t', "track", &opts.track, "set upstream info for new branch",
931 BRANCH_TRACK_EXPLICIT),
932 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
933 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
934 2),
935 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
936 3),
937 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
938 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
939 OPT_STRING(0, "conflict", &conflict_style, "style",
940 "conflict style (merge or diff3)"),
941 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
942 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
943 "second guess 'git checkout no-such-branch'",
944 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
945 OPT_END(),
946 };
947
948 memset(&opts, 0, sizeof(opts));
949 memset(&new, 0, sizeof(new));
950
951 gitmodules_config();
952 git_config(git_checkout_config, &opts);
953
954 opts.track = BRANCH_TRACK_UNSPECIFIED;
955
956 argc = parse_options(argc, argv, prefix, options, checkout_usage,
957 PARSE_OPT_KEEP_DASHDASH);
958
959 /* we can assume from now on new_branch = !new_branch_force */
960 if (opts.new_branch && opts.new_branch_force)
961 die(_("-B cannot be used with -b"));
962
963 /* copy -B over to -b, so that we can just check the latter */
964 if (opts.new_branch_force)
965 opts.new_branch = opts.new_branch_force;
966
967 if (patch_mode && (opts.track > 0 || opts.new_branch
968 || opts.new_branch_log || opts.merge || opts.force
969 || opts.force_detach))
970 die (_("--patch is incompatible with all other options"));
971
972 if (opts.force_detach && (opts.new_branch || opts.new_orphan_branch))
973 die(_("--detach cannot be used with -b/-B/--orphan"));
974 if (opts.force_detach && 0 < opts.track)
975 die(_("--detach cannot be used with -t"));
976
977 /* --track without -b should DWIM */
978 if (0 < opts.track && !opts.new_branch) {
979 const char *argv0 = argv[0];
980 if (!argc || !strcmp(argv0, "--"))
981 die (_("--track needs a branch name"));
982 if (!prefixcmp(argv0, "refs/"))
983 argv0 += 5;
984 if (!prefixcmp(argv0, "remotes/"))
985 argv0 += 8;
986 argv0 = strchr(argv0, '/');
987 if (!argv0 || !argv0[1])
988 die (_("Missing branch name; try -b"));
989 opts.new_branch = argv0 + 1;
990 }
991
992 if (opts.new_orphan_branch) {
993 if (opts.new_branch)
994 die(_("--orphan and -b|-B are mutually exclusive"));
995 if (opts.track > 0)
996 die(_("--orphan cannot be used with -t"));
997 opts.new_branch = opts.new_orphan_branch;
998 }
999
1000 if (conflict_style) {
1001 opts.merge = 1; /* implied */
1002 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
1003 }
1004
1005 if (opts.force && opts.merge)
1006 die(_("git checkout: -f and -m are incompatible"));
1007
1008 /*
1009 * Extract branch name from command line arguments, so
1010 * all that is left is pathspecs.
1011 *
1012 * Handle
1013 *
1014 * 1) git checkout <tree> -- [<paths>]
1015 * 2) git checkout -- [<paths>]
1016 * 3) git checkout <something> [<paths>]
1017 *
1018 * including "last branch" syntax and DWIM-ery for names of
1019 * remote branches, erroring out for invalid or ambiguous cases.
1020 */
1021 if (argc) {
1022 int dwim_ok =
1023 !patch_mode &&
1024 dwim_new_local_branch &&
1025 opts.track == BRANCH_TRACK_UNSPECIFIED &&
1026 !opts.new_branch;
1027 int n = parse_branchname_arg(argc, argv, dwim_ok,
1028 &new, &source_tree, rev, &opts.new_branch);
1029 argv += n;
1030 argc -= n;
1031 }
1032
1033 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
1034 opts.track = git_branch_track;
1035
1036 if (argc) {
1037 const char **pathspec = get_pathspec(prefix, argv);
1038
1039 if (!pathspec)
1040 die(_("invalid path specification"));
1041
1042 if (patch_mode)
1043 return interactive_checkout(new.name, pathspec, &opts);
1044
1045 /* Checkout paths */
1046 if (opts.new_branch) {
1047 if (argc == 1) {
1048 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]);
1049 } else {
1050 die(_("git checkout: updating paths is incompatible with switching branches."));
1051 }
1052 }
1053
1054 if (opts.force_detach)
1055 die(_("git checkout: --detach does not take a path argument"));
1056
1057 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
1058 die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index."));
1059
1060 return checkout_paths(source_tree, pathspec, prefix, &opts);
1061 }
1062
1063 if (patch_mode)
1064 return interactive_checkout(new.name, NULL, &opts);
1065
1066 if (opts.new_branch) {
1067 struct strbuf buf = STRBUF_INIT;
1068
1069 opts.branch_exists = validate_new_branchname(opts.new_branch, &buf,
1070 !!opts.new_branch_force, 0);
1071
1072 strbuf_release(&buf);
1073 }
1074
1075 if (new.name && !new.commit) {
1076 die(_("Cannot switch branch to a non-commit."));
1077 }
1078 if (opts.writeout_stage)
1079 die(_("--ours/--theirs is incompatible with switching branches."));
1080
1081 return switch_branches(&opts, &new);
1082 }