5 #include "parse-options.h"
10 #include "run-command.h"
16 static GIT_PATH_FUNC(git_path_bisect_terms
, "BISECT_TERMS")
17 static GIT_PATH_FUNC(git_path_bisect_expected_rev
, "BISECT_EXPECTED_REV")
18 static GIT_PATH_FUNC(git_path_bisect_ancestors_ok
, "BISECT_ANCESTORS_OK")
19 static GIT_PATH_FUNC(git_path_bisect_start
, "BISECT_START")
20 static GIT_PATH_FUNC(git_path_bisect_log
, "BISECT_LOG")
21 static GIT_PATH_FUNC(git_path_bisect_names
, "BISECT_NAMES")
22 static GIT_PATH_FUNC(git_path_bisect_first_parent
, "BISECT_FIRST_PARENT")
23 static GIT_PATH_FUNC(git_path_bisect_run
, "BISECT_RUN")
25 #define BUILTIN_GIT_BISECT_START_USAGE \
26 N_("git bisect start [--term-{new,bad}=<term> --term-{old,good}=<term>]" \
27 " [--no-checkout] [--first-parent] [<bad> [<good>...]] [--]" \
29 #define BUILTIN_GIT_BISECT_STATE_USAGE \
30 N_("git bisect (good|bad) [<rev>...]")
31 #define BUILTIN_GIT_BISECT_TERMS_USAGE \
32 "git bisect terms [--term-good | --term-bad]"
33 #define BUILTIN_GIT_BISECT_SKIP_USAGE \
34 N_("git bisect skip [(<rev>|<range>)...]")
35 #define BUILTIN_GIT_BISECT_NEXT_USAGE \
37 #define BUILTIN_GIT_BISECT_RESET_USAGE \
38 N_("git bisect reset [<commit>]")
39 #define BUILTIN_GIT_BISECT_VISUALIZE_USAGE \
40 "git bisect visualize"
41 #define BUILTIN_GIT_BISECT_REPLAY_USAGE \
42 N_("git bisect replay <logfile>")
43 #define BUILTIN_GIT_BISECT_LOG_USAGE \
45 #define BUILTIN_GIT_BISECT_RUN_USAGE \
46 N_("git bisect run <cmd>...")
48 static const char * const git_bisect_usage
[] = {
49 BUILTIN_GIT_BISECT_START_USAGE
,
50 BUILTIN_GIT_BISECT_STATE_USAGE
,
51 BUILTIN_GIT_BISECT_TERMS_USAGE
,
52 BUILTIN_GIT_BISECT_SKIP_USAGE
,
53 BUILTIN_GIT_BISECT_NEXT_USAGE
,
54 BUILTIN_GIT_BISECT_RESET_USAGE
,
55 BUILTIN_GIT_BISECT_VISUALIZE_USAGE
,
56 BUILTIN_GIT_BISECT_REPLAY_USAGE
,
57 BUILTIN_GIT_BISECT_LOG_USAGE
,
58 BUILTIN_GIT_BISECT_RUN_USAGE
,
62 struct add_bisect_ref_data
{
63 struct rev_info
*revs
;
64 unsigned int object_flags
;
72 static void free_terms(struct bisect_terms
*terms
)
74 FREE_AND_NULL(terms
->term_good
);
75 FREE_AND_NULL(terms
->term_bad
);
78 static void set_terms(struct bisect_terms
*terms
, const char *bad
,
81 free((void *)terms
->term_good
);
82 terms
->term_good
= xstrdup(good
);
83 free((void *)terms
->term_bad
);
84 terms
->term_bad
= xstrdup(bad
);
87 static const char vocab_bad
[] = "bad|new";
88 static const char vocab_good
[] = "good|old";
90 static int bisect_autostart(struct bisect_terms
*terms
);
93 * Check whether the string `term` belongs to the set of strings
94 * included in the variable arguments.
97 static int one_of(const char *term
, ...)
103 va_start(matches
, term
);
104 while (!res
&& (match
= va_arg(matches
, const char *)))
105 res
= !strcmp(term
, match
);
112 * return code BISECT_INTERNAL_SUCCESS_MERGE_BASE
113 * and BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND are codes
114 * that indicate special success.
117 static int is_bisect_success(enum bisect_error res
)
120 res
== BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND
||
121 res
== BISECT_INTERNAL_SUCCESS_MERGE_BASE
;
124 static int write_in_file(const char *path
, const char *mode
, const char *format
, va_list args
)
129 if (strcmp(mode
, "w") && strcmp(mode
, "a"))
130 BUG("write-in-file does not support '%s' mode", mode
);
131 fp
= fopen(path
, mode
);
133 return error_errno(_("cannot open file '%s' in mode '%s'"), path
, mode
);
134 res
= vfprintf(fp
, format
, args
);
137 int saved_errno
= errno
;
140 return error_errno(_("could not write to file '%s'"), path
);
146 __attribute__((format (printf
, 2, 3)))
147 static int write_to_file(const char *path
, const char *format
, ...)
152 va_start(args
, format
);
153 res
= write_in_file(path
, "w", format
, args
);
159 __attribute__((format (printf
, 2, 3)))
160 static int append_to_file(const char *path
, const char *format
, ...)
165 va_start(args
, format
);
166 res
= write_in_file(path
, "a", format
, args
);
172 static int print_file_to_stdout(const char *path
)
174 int fd
= open(path
, O_RDONLY
);
178 return error_errno(_("cannot open file '%s' for reading"), path
);
179 if (copy_fd(fd
, 1) < 0)
180 ret
= error_errno(_("failed to read '%s'"), path
);
185 static int check_term_format(const char *term
, const char *orig_term
)
188 char *new_term
= xstrfmt("refs/bisect/%s", term
);
190 res
= check_refname_format(new_term
, 0);
194 return error(_("'%s' is not a valid term"), term
);
196 if (one_of(term
, "help", "start", "skip", "next", "reset",
197 "visualize", "view", "replay", "log", "run", "terms", NULL
))
198 return error(_("can't use the builtin command '%s' as a term"), term
);
201 * In theory, nothing prevents swapping completely good and bad,
202 * but this situation could be confusing and hasn't been tested
203 * enough. Forbid it for now.
206 if ((strcmp(orig_term
, "bad") && one_of(term
, "bad", "new", NULL
)) ||
207 (strcmp(orig_term
, "good") && one_of(term
, "good", "old", NULL
)))
208 return error(_("can't change the meaning of the term '%s'"), term
);
213 static int write_terms(const char *bad
, const char *good
)
217 if (!strcmp(bad
, good
))
218 return error(_("please use two different terms"));
220 if (check_term_format(bad
, "bad") || check_term_format(good
, "good"))
223 res
= write_to_file(git_path_bisect_terms(), "%s\n%s\n", bad
, good
);
228 static int bisect_reset(const char *commit
)
230 struct strbuf branch
= STRBUF_INIT
;
233 if (strbuf_read_file(&branch
, git_path_bisect_start(), 0) < 1) {
234 printf(_("We are not bisecting.\n"));
237 strbuf_rtrim(&branch
);
239 struct object_id oid
;
241 if (get_oid_commit(commit
, &oid
))
242 return error(_("'%s' is not a valid commit"), commit
);
243 strbuf_addstr(&branch
, commit
);
246 if (!ref_exists("BISECT_HEAD")) {
247 struct child_process cmd
= CHILD_PROCESS_INIT
;
250 strvec_pushl(&cmd
.args
, "checkout", "--ignore-other-worktrees",
251 branch
.buf
, "--", NULL
);
252 if (run_command(&cmd
)) {
253 error(_("could not check out original"
254 " HEAD '%s'. Try 'git bisect"
255 " reset <commit>'."), branch
.buf
);
256 strbuf_release(&branch
);
261 strbuf_release(&branch
);
262 return bisect_clean_state();
265 static void log_commit(FILE *fp
, char *fmt
, const char *state
,
266 struct commit
*commit
)
268 struct pretty_print_context pp
= {0};
269 struct strbuf commit_msg
= STRBUF_INIT
;
270 char *label
= xstrfmt(fmt
, state
);
272 format_commit_message(commit
, "%s", &commit_msg
, &pp
);
274 fprintf(fp
, "# %s: [%s] %s\n", label
, oid_to_hex(&commit
->object
.oid
),
277 strbuf_release(&commit_msg
);
281 static int bisect_write(const char *state
, const char *rev
,
282 const struct bisect_terms
*terms
, int nolog
)
284 struct strbuf tag
= STRBUF_INIT
;
285 struct object_id oid
;
286 struct commit
*commit
;
290 if (!strcmp(state
, terms
->term_bad
)) {
291 strbuf_addf(&tag
, "refs/bisect/%s", state
);
292 } else if (one_of(state
, terms
->term_good
, "skip", NULL
)) {
293 strbuf_addf(&tag
, "refs/bisect/%s-%s", state
, rev
);
295 res
= error(_("Bad bisect_write argument: %s"), state
);
299 if (get_oid(rev
, &oid
)) {
300 res
= error(_("couldn't get the oid of the rev '%s'"), rev
);
304 if (update_ref(NULL
, tag
.buf
, &oid
, NULL
, 0,
305 UPDATE_REFS_MSG_ON_ERR
)) {
310 fp
= fopen(git_path_bisect_log(), "a");
312 res
= error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
316 commit
= lookup_commit_reference(the_repository
, &oid
);
317 log_commit(fp
, "%s", state
, commit
);
320 fprintf(fp
, "git bisect %s %s\n", state
, rev
);
325 strbuf_release(&tag
);
329 static int check_and_set_terms(struct bisect_terms
*terms
, const char *cmd
)
331 int has_term_file
= !is_empty_or_missing_file(git_path_bisect_terms());
333 if (one_of(cmd
, "skip", "start", "terms", NULL
))
336 if (has_term_file
&& strcmp(cmd
, terms
->term_bad
) &&
337 strcmp(cmd
, terms
->term_good
))
338 return error(_("Invalid command: you're currently in a "
339 "%s/%s bisect"), terms
->term_bad
,
342 if (!has_term_file
) {
343 if (one_of(cmd
, "bad", "good", NULL
)) {
344 set_terms(terms
, "bad", "good");
345 return write_terms(terms
->term_bad
, terms
->term_good
);
347 if (one_of(cmd
, "new", "old", NULL
)) {
348 set_terms(terms
, "new", "old");
349 return write_terms(terms
->term_bad
, terms
->term_good
);
356 static int inc_nr(const char *refname UNUSED
,
357 const struct object_id
*oid UNUSED
,
358 int flag UNUSED
, void *cb_data
)
360 unsigned int *nr
= (unsigned int *)cb_data
;
365 static const char need_bad_and_good_revision_warning
[] =
366 N_("You need to give me at least one %s and %s revision.\n"
367 "You can use \"git bisect %s\" and \"git bisect %s\" for that.");
369 static const char need_bisect_start_warning
[] =
370 N_("You need to start by \"git bisect start\".\n"
371 "You then need to give me at least one %s and %s revision.\n"
372 "You can use \"git bisect %s\" and \"git bisect %s\" for that.");
374 static int decide_next(const struct bisect_terms
*terms
,
375 const char *current_term
, int missing_good
,
378 if (!missing_good
&& !missing_bad
)
383 if (missing_good
&& !missing_bad
&&
384 !strcmp(current_term
, terms
->term_good
)) {
387 * have bad (or new) but not good (or old). We could bisect
388 * although this is less optimum.
390 warning(_("bisecting only with a %s commit"), terms
->term_bad
);
394 * TRANSLATORS: Make sure to include [Y] and [n] in your
395 * translation. The program will only accept English input
398 yesno
= git_prompt(_("Are you sure [Y/n]? "), PROMPT_ECHO
);
399 if (starts_with(yesno
, "N") || starts_with(yesno
, "n"))
404 if (!is_empty_or_missing_file(git_path_bisect_start()))
405 return error(_(need_bad_and_good_revision_warning
),
406 vocab_bad
, vocab_good
, vocab_bad
, vocab_good
);
408 return error(_(need_bisect_start_warning
),
409 vocab_good
, vocab_bad
, vocab_good
, vocab_bad
);
412 static void bisect_status(struct bisect_state
*state
,
413 const struct bisect_terms
*terms
)
415 char *bad_ref
= xstrfmt("refs/bisect/%s", terms
->term_bad
);
416 char *good_glob
= xstrfmt("%s-*", terms
->term_good
);
418 if (ref_exists(bad_ref
))
421 for_each_glob_ref_in(inc_nr
, good_glob
, "refs/bisect/",
422 (void *) &state
->nr_good
);
428 __attribute__((format (printf
, 1, 2)))
429 static void bisect_log_printf(const char *fmt
, ...)
431 struct strbuf buf
= STRBUF_INIT
;
435 strbuf_vaddf(&buf
, fmt
, ap
);
438 printf("%s", buf
.buf
);
439 append_to_file(git_path_bisect_log(), "# %s", buf
.buf
);
441 strbuf_release(&buf
);
444 static void bisect_print_status(const struct bisect_terms
*terms
)
446 struct bisect_state state
= { 0 };
448 bisect_status(&state
, terms
);
450 /* If we had both, we'd already be started, and shouldn't get here. */
451 if (state
.nr_good
&& state
.nr_bad
)
454 if (!state
.nr_good
&& !state
.nr_bad
)
455 bisect_log_printf(_("status: waiting for both good and bad commits\n"));
456 else if (state
.nr_good
)
457 bisect_log_printf(Q_("status: waiting for bad commit, %d good commit known\n",
458 "status: waiting for bad commit, %d good commits known\n",
459 state
.nr_good
), state
.nr_good
);
461 bisect_log_printf(_("status: waiting for good commit(s), bad commit known\n"));
464 static int bisect_next_check(const struct bisect_terms
*terms
,
465 const char *current_term
)
467 struct bisect_state state
= { 0 };
468 bisect_status(&state
, terms
);
469 return decide_next(terms
, current_term
, !state
.nr_good
, !state
.nr_bad
);
472 static int get_terms(struct bisect_terms
*terms
)
474 struct strbuf str
= STRBUF_INIT
;
478 fp
= fopen(git_path_bisect_terms(), "r");
485 strbuf_getline_lf(&str
, fp
);
486 terms
->term_bad
= strbuf_detach(&str
, NULL
);
487 strbuf_getline_lf(&str
, fp
);
488 terms
->term_good
= strbuf_detach(&str
, NULL
);
493 strbuf_release(&str
);
497 static int bisect_terms(struct bisect_terms
*terms
, const char *option
)
499 if (get_terms(terms
))
500 return error(_("no terms defined"));
503 printf(_("Your current terms are %s for the old state\n"
504 "and %s for the new state.\n"),
505 terms
->term_good
, terms
->term_bad
);
508 if (one_of(option
, "--term-good", "--term-old", NULL
))
509 printf("%s\n", terms
->term_good
);
510 else if (one_of(option
, "--term-bad", "--term-new", NULL
))
511 printf("%s\n", terms
->term_bad
);
513 return error(_("invalid argument %s for 'git bisect terms'.\n"
514 "Supported options are: "
515 "--term-good|--term-old and "
516 "--term-bad|--term-new."), option
);
521 static int bisect_append_log_quoted(const char **argv
)
524 FILE *fp
= fopen(git_path_bisect_log(), "a");
525 struct strbuf orig_args
= STRBUF_INIT
;
530 if (fprintf(fp
, "git bisect start") < 1) {
535 sq_quote_argv(&orig_args
, argv
);
536 if (fprintf(fp
, "%s\n", orig_args
.buf
) < 1)
541 strbuf_release(&orig_args
);
545 static int add_bisect_ref(const char *refname
, const struct object_id
*oid
,
546 int flags UNUSED
, void *cb
)
548 struct add_bisect_ref_data
*data
= cb
;
550 add_pending_oid(data
->revs
, refname
, oid
, data
->object_flags
);
555 static int prepare_revs(struct bisect_terms
*terms
, struct rev_info
*revs
)
558 struct add_bisect_ref_data cb
= { revs
};
559 char *good
= xstrfmt("%s-*", terms
->term_good
);
562 * We cannot use terms->term_bad directly in
563 * for_each_glob_ref_in() and we have to append a '*' to it,
564 * otherwise for_each_glob_ref_in() will append '/' and '*'.
566 char *bad
= xstrfmt("%s*", terms
->term_bad
);
569 * It is important to reset the flags used by revision walks
570 * as the previous call to bisect_next_all() in turn
571 * sets up a revision walk.
573 reset_revision_walk();
574 init_revisions(revs
, NULL
);
575 setup_revisions(0, NULL
, revs
, NULL
);
576 for_each_glob_ref_in(add_bisect_ref
, bad
, "refs/bisect/", &cb
);
577 cb
.object_flags
= UNINTERESTING
;
578 for_each_glob_ref_in(add_bisect_ref
, good
, "refs/bisect/", &cb
);
579 if (prepare_revision_walk(revs
))
580 res
= error(_("revision walk setup failed\n"));
587 static int bisect_skipped_commits(struct bisect_terms
*terms
)
591 struct rev_info revs
;
592 struct commit
*commit
;
593 struct pretty_print_context pp
= {0};
594 struct strbuf commit_name
= STRBUF_INIT
;
596 res
= prepare_revs(terms
, &revs
);
600 fp
= fopen(git_path_bisect_log(), "a");
602 return error_errno(_("could not open '%s' for appending"),
603 git_path_bisect_log());
605 if (fprintf(fp
, "# only skipped commits left to test\n") < 0)
606 return error_errno(_("failed to write to '%s'"), git_path_bisect_log());
608 while ((commit
= get_revision(&revs
)) != NULL
) {
609 strbuf_reset(&commit_name
);
610 format_commit_message(commit
, "%s",
612 fprintf(fp
, "# possible first %s commit: [%s] %s\n",
613 terms
->term_bad
, oid_to_hex(&commit
->object
.oid
),
618 * Reset the flags used by revision walks in case
619 * there is another revision walk after this one.
621 reset_revision_walk();
623 strbuf_release(&commit_name
);
624 release_revisions(&revs
);
629 static int bisect_successful(struct bisect_terms
*terms
)
631 struct object_id oid
;
632 struct commit
*commit
;
633 struct pretty_print_context pp
= {0};
634 struct strbuf commit_name
= STRBUF_INIT
;
635 char *bad_ref
= xstrfmt("refs/bisect/%s",terms
->term_bad
);
638 read_ref(bad_ref
, &oid
);
639 commit
= lookup_commit_reference_by_name(bad_ref
);
640 format_commit_message(commit
, "%s", &commit_name
, &pp
);
642 res
= append_to_file(git_path_bisect_log(), "# first %s commit: [%s] %s\n",
643 terms
->term_bad
, oid_to_hex(&commit
->object
.oid
),
646 strbuf_release(&commit_name
);
651 static enum bisect_error
bisect_next(struct bisect_terms
*terms
, const char *prefix
)
653 enum bisect_error res
;
655 if (bisect_autostart(terms
))
656 return BISECT_FAILED
;
658 if (bisect_next_check(terms
, terms
->term_good
))
659 return BISECT_FAILED
;
661 /* Perform all bisection computation */
662 res
= bisect_next_all(the_repository
, prefix
);
664 if (res
== BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND
) {
665 res
= bisect_successful(terms
);
666 return res
? res
: BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND
;
667 } else if (res
== BISECT_ONLY_SKIPPED_LEFT
) {
668 res
= bisect_skipped_commits(terms
);
669 return res
? res
: BISECT_ONLY_SKIPPED_LEFT
;
674 static enum bisect_error
bisect_auto_next(struct bisect_terms
*terms
, const char *prefix
)
676 if (bisect_next_check(terms
, NULL
)) {
677 bisect_print_status(terms
);
681 return bisect_next(terms
, prefix
);
684 static enum bisect_error
bisect_start(struct bisect_terms
*terms
, int argc
,
688 int first_parent_only
= 0;
689 int i
, has_double_dash
= 0, must_write_terms
= 0, bad_seen
= 0;
690 int flags
, pathspec_pos
;
691 enum bisect_error res
= BISECT_OK
;
692 struct string_list revs
= STRING_LIST_INIT_DUP
;
693 struct string_list states
= STRING_LIST_INIT_DUP
;
694 struct strbuf start_head
= STRBUF_INIT
;
695 struct strbuf bisect_names
= STRBUF_INIT
;
696 struct object_id head_oid
;
697 struct object_id oid
;
700 if (is_bare_repository())
704 * Check for one bad and then some good revisions
706 for (i
= 0; i
< argc
; i
++) {
707 if (!strcmp(argv
[i
], "--")) {
713 for (i
= 0; i
< argc
; i
++) {
714 const char *arg
= argv
[i
];
715 if (!strcmp(argv
[i
], "--")) {
717 } else if (!strcmp(arg
, "--no-checkout")) {
719 } else if (!strcmp(arg
, "--first-parent")) {
720 first_parent_only
= 1;
721 } else if (!strcmp(arg
, "--term-good") ||
722 !strcmp(arg
, "--term-old")) {
725 return error(_("'' is not a valid term"));
726 must_write_terms
= 1;
727 free((void *) terms
->term_good
);
728 terms
->term_good
= xstrdup(argv
[i
]);
729 } else if (skip_prefix(arg
, "--term-good=", &arg
) ||
730 skip_prefix(arg
, "--term-old=", &arg
)) {
731 must_write_terms
= 1;
732 free((void *) terms
->term_good
);
733 terms
->term_good
= xstrdup(arg
);
734 } else if (!strcmp(arg
, "--term-bad") ||
735 !strcmp(arg
, "--term-new")) {
738 return error(_("'' is not a valid term"));
739 must_write_terms
= 1;
740 free((void *) terms
->term_bad
);
741 terms
->term_bad
= xstrdup(argv
[i
]);
742 } else if (skip_prefix(arg
, "--term-bad=", &arg
) ||
743 skip_prefix(arg
, "--term-new=", &arg
)) {
744 must_write_terms
= 1;
745 free((void *) terms
->term_bad
);
746 terms
->term_bad
= xstrdup(arg
);
747 } else if (starts_with(arg
, "--")) {
748 return error(_("unrecognized option: '%s'"), arg
);
749 } else if (!get_oidf(&oid
, "%s^{commit}", arg
)) {
750 string_list_append(&revs
, oid_to_hex(&oid
));
751 } else if (has_double_dash
) {
752 die(_("'%s' does not appear to be a valid "
761 * The user ran "git bisect start <sha1> <sha1>", hence did not
762 * explicitly specify the terms, but we are already starting to
763 * set references named with the default terms, and won't be able
764 * to change afterwards.
767 must_write_terms
= 1;
768 for (i
= 0; i
< revs
.nr
; i
++) {
770 string_list_append(&states
, terms
->term_good
);
773 string_list_append(&states
, terms
->term_bad
);
780 head
= resolve_ref_unsafe("HEAD", 0, &head_oid
, &flags
);
782 if (get_oid("HEAD", &head_oid
))
783 return error(_("bad HEAD - I need a HEAD"));
786 * Check if we are bisecting
788 if (!is_empty_or_missing_file(git_path_bisect_start())) {
789 /* Reset to the rev from where we started */
790 strbuf_read_file(&start_head
, git_path_bisect_start(), 0);
791 strbuf_trim(&start_head
);
793 struct child_process cmd
= CHILD_PROCESS_INIT
;
796 strvec_pushl(&cmd
.args
, "checkout", start_head
.buf
,
798 if (run_command(&cmd
)) {
799 res
= error(_("checking out '%s' failed."
800 " Try 'git bisect start "
807 /* Get the rev from where we start. */
808 if (!get_oid(head
, &head_oid
) &&
809 !starts_with(head
, "refs/heads/")) {
810 strbuf_reset(&start_head
);
811 strbuf_addstr(&start_head
, oid_to_hex(&head_oid
));
812 } else if (!get_oid(head
, &head_oid
) &&
813 skip_prefix(head
, "refs/heads/", &head
)) {
814 strbuf_addstr(&start_head
, head
);
816 return error(_("bad HEAD - strange symbolic ref"));
821 * Get rid of any old bisect state.
823 if (bisect_clean_state())
824 return BISECT_FAILED
;
827 * Write new start state
829 write_file(git_path_bisect_start(), "%s\n", start_head
.buf
);
831 if (first_parent_only
)
832 write_file(git_path_bisect_first_parent(), "\n");
835 if (get_oid(start_head
.buf
, &oid
) < 0) {
836 res
= error(_("invalid ref: '%s'"), start_head
.buf
);
839 if (update_ref(NULL
, "BISECT_HEAD", &oid
, NULL
, 0,
840 UPDATE_REFS_MSG_ON_ERR
)) {
846 if (pathspec_pos
< argc
- 1)
847 sq_quote_argv(&bisect_names
, argv
+ pathspec_pos
);
848 write_file(git_path_bisect_names(), "%s\n", bisect_names
.buf
);
850 for (i
= 0; i
< states
.nr
; i
++)
851 if (bisect_write(states
.items
[i
].string
,
852 revs
.items
[i
].string
, terms
, 1)) {
857 if (must_write_terms
&& write_terms(terms
->term_bad
,
863 res
= bisect_append_log_quoted(argv
);
868 string_list_clear(&revs
, 0);
869 string_list_clear(&states
, 0);
870 strbuf_release(&start_head
);
871 strbuf_release(&bisect_names
);
875 res
= bisect_auto_next(terms
, NULL
);
876 if (!is_bisect_success(res
))
877 bisect_clean_state();
881 static inline int file_is_not_empty(const char *path
)
883 return !is_empty_or_missing_file(path
);
886 static int bisect_autostart(struct bisect_terms
*terms
)
891 if (file_is_not_empty(git_path_bisect_start()))
894 fprintf_ln(stderr
, _("You need to start by \"git bisect "
897 if (!isatty(STDIN_FILENO
))
901 * TRANSLATORS: Make sure to include [Y] and [n] in your
902 * translation. The program will only accept English input
905 yesno
= git_prompt(_("Do you want me to do it for you "
906 "[Y/n]? "), PROMPT_ECHO
);
907 res
= tolower(*yesno
) == 'n' ?
908 -1 : bisect_start(terms
, 0, empty_strvec
);
913 static enum bisect_error
bisect_state(struct bisect_terms
*terms
, int argc
,
917 int i
, verify_expected
= 1;
918 struct object_id oid
, expected
;
919 struct strbuf buf
= STRBUF_INIT
;
920 struct oid_array revs
= OID_ARRAY_INIT
;
923 return error(_("Please call `--bisect-state` with at least one argument"));
925 if (bisect_autostart(terms
))
926 return BISECT_FAILED
;
929 if (check_and_set_terms(terms
, state
) ||
930 !one_of(state
, terms
->term_good
, terms
->term_bad
, "skip", NULL
))
931 return BISECT_FAILED
;
935 if (argc
> 1 && !strcmp(state
, terms
->term_bad
))
936 return error(_("'git bisect %s' can take only one argument."), terms
->term_bad
);
939 const char *head
= "BISECT_HEAD";
940 enum get_oid_result res_head
= get_oid(head
, &oid
);
942 if (res_head
== MISSING_OBJECT
) {
944 res_head
= get_oid(head
, &oid
);
948 error(_("Bad rev input: %s"), head
);
949 oid_array_append(&revs
, &oid
);
953 * All input revs must be checked before executing bisect_write()
954 * to discard junk revs.
957 for (; argc
; argc
--, argv
++) {
958 struct commit
*commit
;
960 if (get_oid(*argv
, &oid
)){
961 error(_("Bad rev input: %s"), *argv
);
962 oid_array_clear(&revs
);
963 return BISECT_FAILED
;
966 commit
= lookup_commit_reference(the_repository
, &oid
);
968 die(_("Bad rev input (not a commit): %s"), *argv
);
970 oid_array_append(&revs
, &commit
->object
.oid
);
973 if (strbuf_read_file(&buf
, git_path_bisect_expected_rev(), 0) < the_hash_algo
->hexsz
||
974 get_oid_hex(buf
.buf
, &expected
) < 0)
975 verify_expected
= 0; /* Ignore invalid file contents */
976 strbuf_release(&buf
);
978 for (i
= 0; i
< revs
.nr
; i
++) {
979 if (bisect_write(state
, oid_to_hex(&revs
.oid
[i
]), terms
, 0)) {
980 oid_array_clear(&revs
);
981 return BISECT_FAILED
;
983 if (verify_expected
&& !oideq(&revs
.oid
[i
], &expected
)) {
984 unlink_or_warn(git_path_bisect_ancestors_ok());
985 unlink_or_warn(git_path_bisect_expected_rev());
990 oid_array_clear(&revs
);
991 return bisect_auto_next(terms
, NULL
);
994 static enum bisect_error
bisect_log(void)
997 const char* filename
= git_path_bisect_log();
999 if (is_empty_or_missing_file(filename
))
1000 return error(_("We are not bisecting."));
1002 fd
= open(filename
, O_RDONLY
);
1004 return BISECT_FAILED
;
1006 status
= copy_fd(fd
, STDOUT_FILENO
);
1008 return status
? BISECT_FAILED
: BISECT_OK
;
1011 static int process_replay_line(struct bisect_terms
*terms
, struct strbuf
*line
)
1013 const char *p
= line
->buf
+ strspn(line
->buf
, " \t");
1014 char *word_end
, *rev
;
1016 if ((!skip_prefix(p
, "git bisect", &p
) &&
1017 !skip_prefix(p
, "git-bisect", &p
)) || !isspace(*p
))
1019 p
+= strspn(p
, " \t");
1021 word_end
= (char *)p
+ strcspn(p
, " \t");
1022 rev
= word_end
+ strspn(word_end
, " \t");
1023 *word_end
= '\0'; /* NUL-terminate the word */
1026 if (check_and_set_terms(terms
, p
))
1029 if (!strcmp(p
, "start")) {
1030 struct strvec argv
= STRVEC_INIT
;
1032 sq_dequote_to_strvec(rev
, &argv
);
1033 res
= bisect_start(terms
, argv
.nr
, argv
.v
);
1034 strvec_clear(&argv
);
1038 if (one_of(p
, terms
->term_good
,
1039 terms
->term_bad
, "skip", NULL
))
1040 return bisect_write(p
, rev
, terms
, 0);
1042 if (!strcmp(p
, "terms")) {
1043 struct strvec argv
= STRVEC_INIT
;
1045 sq_dequote_to_strvec(rev
, &argv
);
1046 res
= bisect_terms(terms
, argv
.nr
== 1 ? argv
.v
[0] : NULL
);
1047 strvec_clear(&argv
);
1050 error(_("'%s'?? what are you talking about?"), p
);
1055 static enum bisect_error
bisect_replay(struct bisect_terms
*terms
, const char *filename
)
1058 enum bisect_error res
= BISECT_OK
;
1059 struct strbuf line
= STRBUF_INIT
;
1061 if (is_empty_or_missing_file(filename
))
1062 return error(_("cannot read file '%s' for replaying"), filename
);
1064 if (bisect_reset(NULL
))
1065 return BISECT_FAILED
;
1067 fp
= fopen(filename
, "r");
1069 return BISECT_FAILED
;
1071 while ((strbuf_getline(&line
, fp
) != EOF
) && !res
)
1072 res
= process_replay_line(terms
, &line
);
1074 strbuf_release(&line
);
1078 return BISECT_FAILED
;
1080 return bisect_auto_next(terms
, NULL
);
1083 static enum bisect_error
bisect_skip(struct bisect_terms
*terms
, int argc
,
1087 enum bisect_error res
;
1088 struct strvec argv_state
= STRVEC_INIT
;
1090 strvec_push(&argv_state
, "skip");
1092 for (i
= 0; i
< argc
; i
++) {
1093 const char *dotdot
= strstr(argv
[i
], "..");
1096 struct rev_info revs
;
1097 struct commit
*commit
;
1099 init_revisions(&revs
, NULL
);
1100 setup_revisions(2, argv
+ i
- 1, &revs
, NULL
);
1102 if (prepare_revision_walk(&revs
))
1103 die(_("revision walk setup failed\n"));
1104 while ((commit
= get_revision(&revs
)) != NULL
)
1105 strvec_push(&argv_state
,
1106 oid_to_hex(&commit
->object
.oid
));
1108 reset_revision_walk();
1109 release_revisions(&revs
);
1111 strvec_push(&argv_state
, argv
[i
]);
1114 res
= bisect_state(terms
, argv_state
.nr
, argv_state
.v
);
1116 strvec_clear(&argv_state
);
1120 static int bisect_visualize(struct bisect_terms
*terms
, int argc
,
1123 struct child_process cmd
= CHILD_PROCESS_INIT
;
1124 struct strbuf sb
= STRBUF_INIT
;
1126 if (bisect_next_check(terms
, NULL
) != 0)
1127 return BISECT_FAILED
;
1131 if ((getenv("DISPLAY") || getenv("SESSIONNAME") || getenv("MSYSTEM") ||
1132 getenv("SECURITYSESSIONID")) && exists_in_PATH("gitk")) {
1133 strvec_push(&cmd
.args
, "gitk");
1135 strvec_push(&cmd
.args
, "log");
1139 if (argv
[0][0] == '-') {
1140 strvec_push(&cmd
.args
, "log");
1142 } else if (strcmp(argv
[0], "tig") && !starts_with(argv
[0], "git"))
1145 strvec_pushv(&cmd
.args
, argv
);
1148 strvec_pushl(&cmd
.args
, "--bisect", "--", NULL
);
1150 strbuf_read_file(&sb
, git_path_bisect_names(), 0);
1151 sq_dequote_to_strvec(sb
.buf
, &cmd
.args
);
1152 strbuf_release(&sb
);
1154 return run_command(&cmd
);
1157 static int get_first_good(const char *refname UNUSED
,
1158 const struct object_id
*oid
,
1159 int flag UNUSED
, void *cb_data
)
1161 oidcpy(cb_data
, oid
);
1165 static int do_bisect_run(const char *command
)
1167 struct child_process cmd
= CHILD_PROCESS_INIT
;
1169 printf(_("running %s\n"), command
);
1171 strvec_push(&cmd
.args
, command
);
1172 return run_command(&cmd
);
1175 static int verify_good(const struct bisect_terms
*terms
, const char *command
)
1178 enum bisect_error res
;
1179 struct object_id good_rev
;
1180 struct object_id current_rev
;
1181 char *good_glob
= xstrfmt("%s-*", terms
->term_good
);
1182 int no_checkout
= ref_exists("BISECT_HEAD");
1184 for_each_glob_ref_in(get_first_good
, good_glob
, "refs/bisect/",
1188 if (read_ref(no_checkout
? "BISECT_HEAD" : "HEAD", ¤t_rev
))
1191 res
= bisect_checkout(&good_rev
, no_checkout
);
1192 if (res
!= BISECT_OK
)
1195 rc
= do_bisect_run(command
);
1197 res
= bisect_checkout(¤t_rev
, no_checkout
);
1198 if (res
!= BISECT_OK
)
1204 static int bisect_run(struct bisect_terms
*terms
, int argc
, const char **argv
)
1206 int res
= BISECT_OK
;
1207 struct strbuf command
= STRBUF_INIT
;
1208 const char *new_state
;
1209 int temporary_stdout_fd
, saved_stdout
;
1210 int is_first_run
= 1;
1212 if (bisect_next_check(terms
, NULL
))
1213 return BISECT_FAILED
;
1216 error(_("bisect run failed: no command provided."));
1217 return BISECT_FAILED
;
1220 sq_quote_argv(&command
, argv
);
1221 strbuf_ltrim(&command
);
1223 res
= do_bisect_run(command
.buf
);
1226 * Exit code 126 and 127 can either come from the shell
1227 * if it was unable to execute or even find the script,
1228 * or from the script itself. Check with a known-good
1229 * revision to avoid trashing the bisect run due to a
1230 * missing or non-executable script.
1232 if (is_first_run
&& (res
== 126 || res
== 127)) {
1233 int rc
= verify_good(terms
, command
.buf
);
1235 if (rc
< 0 || 128 <= rc
) {
1236 error(_("unable to verify %s on good"
1237 " revision"), command
.buf
);
1238 res
= BISECT_FAILED
;
1242 error(_("bogus exit code %d for good revision"),
1244 res
= BISECT_FAILED
;
1249 if (res
< 0 || 128 <= res
) {
1250 error(_("bisect run failed: exit code %d from"
1251 " %s is < 0 or >= 128"), res
, command
.buf
);
1258 new_state
= terms
->term_good
;
1260 new_state
= terms
->term_bad
;
1262 temporary_stdout_fd
= open(git_path_bisect_run(), O_CREAT
| O_WRONLY
| O_TRUNC
, 0666);
1264 if (temporary_stdout_fd
< 0) {
1265 res
= error_errno(_("cannot open file '%s' for writing"), git_path_bisect_run());
1270 saved_stdout
= dup(1);
1271 dup2(temporary_stdout_fd
, 1);
1273 res
= bisect_state(terms
, 1, &new_state
);
1276 dup2(saved_stdout
, 1);
1277 close(saved_stdout
);
1278 close(temporary_stdout_fd
);
1280 print_file_to_stdout(git_path_bisect_run());
1282 if (res
== BISECT_ONLY_SKIPPED_LEFT
)
1283 error(_("bisect run cannot continue any more"));
1284 else if (res
== BISECT_INTERNAL_SUCCESS_MERGE_BASE
) {
1285 puts(_("bisect run success"));
1287 } else if (res
== BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND
) {
1288 puts(_("bisect found first bad commit"));
1291 error(_("bisect run failed: 'git bisect %s'"
1292 " exited with error code %d"), new_state
, res
);
1299 strbuf_release(&command
);
1303 static int cmd_bisect__reset(int argc
, const char **argv
, const char *prefix UNUSED
)
1306 return error(_("'%s' requires either no argument or a commit"),
1307 "git bisect reset");
1308 return bisect_reset(argc
? argv
[0] : NULL
);
1311 static int cmd_bisect__terms(int argc
, const char **argv
, const char *prefix UNUSED
)
1314 struct bisect_terms terms
= { 0 };
1317 return error(_("'%s' requires 0 or 1 argument"),
1318 "git bisect terms");
1319 res
= bisect_terms(&terms
, argc
== 1 ? argv
[0] : NULL
);
1324 static int cmd_bisect__start(int argc
, const char **argv
, const char *prefix UNUSED
)
1327 struct bisect_terms terms
= { 0 };
1329 set_terms(&terms
, "bad", "good");
1330 res
= bisect_start(&terms
, argc
, argv
);
1335 static int cmd_bisect__next(int argc
, const char **argv UNUSED
, const char *prefix
)
1338 struct bisect_terms terms
= { 0 };
1341 return error(_("'%s' requires 0 arguments"),
1344 res
= bisect_next(&terms
, prefix
);
1349 static int cmd_bisect__log(int argc UNUSED
, const char **argv UNUSED
, const char *prefix UNUSED
)
1351 return bisect_log();
1354 static int cmd_bisect__replay(int argc
, const char **argv
, const char *prefix UNUSED
)
1357 struct bisect_terms terms
= { 0 };
1360 return error(_("no logfile given"));
1361 set_terms(&terms
, "bad", "good");
1362 res
= bisect_replay(&terms
, argv
[0]);
1367 static int cmd_bisect__skip(int argc
, const char **argv
, const char *prefix UNUSED
)
1370 struct bisect_terms terms
= { 0 };
1372 set_terms(&terms
, "bad", "good");
1374 res
= bisect_skip(&terms
, argc
, argv
);
1379 static int cmd_bisect__visualize(int argc
, const char **argv
, const char *prefix UNUSED
)
1382 struct bisect_terms terms
= { 0 };
1385 res
= bisect_visualize(&terms
, argc
, argv
);
1390 static int cmd_bisect__run(int argc
, const char **argv
, const char *prefix UNUSED
)
1393 struct bisect_terms terms
= { 0 };
1396 return error(_("'%s' failed: no command provided."), "git bisect run");
1398 res
= bisect_run(&terms
, argc
, argv
);
1403 int cmd_bisect(int argc
, const char **argv
, const char *prefix
)
1406 parse_opt_subcommand_fn
*fn
= NULL
;
1407 struct option options
[] = {
1408 OPT_SUBCOMMAND("reset", &fn
, cmd_bisect__reset
),
1409 OPT_SUBCOMMAND("terms", &fn
, cmd_bisect__terms
),
1410 OPT_SUBCOMMAND("start", &fn
, cmd_bisect__start
),
1411 OPT_SUBCOMMAND("next", &fn
, cmd_bisect__next
),
1412 OPT_SUBCOMMAND("log", &fn
, cmd_bisect__log
),
1413 OPT_SUBCOMMAND("replay", &fn
, cmd_bisect__replay
),
1414 OPT_SUBCOMMAND("skip", &fn
, cmd_bisect__skip
),
1415 OPT_SUBCOMMAND("visualize", &fn
, cmd_bisect__visualize
),
1416 OPT_SUBCOMMAND("view", &fn
, cmd_bisect__visualize
),
1417 OPT_SUBCOMMAND("run", &fn
, cmd_bisect__run
),
1420 argc
= parse_options(argc
, argv
, prefix
, options
, git_bisect_usage
,
1421 PARSE_OPT_SUBCOMMAND_OPTIONAL
);
1424 struct bisect_terms terms
= { 0 };
1427 usage_msg_opt(_("need a command"), git_bisect_usage
, options
);
1429 set_terms(&terms
, "bad", "good");
1431 if (check_and_set_terms(&terms
, argv
[0]))
1432 usage_msg_optf(_("unknown command: '%s'"), git_bisect_usage
,
1434 res
= bisect_state(&terms
, argc
, argv
);
1439 res
= fn(argc
, argv
, prefix
);
1442 return is_bisect_success(res
) ? 0 : -res
;